From 66a50a1b9e6f19356917c80cf417c199ef1bf2c4 Mon Sep 17 00:00:00 2001 From: PARK BYUNG JUN Date: Mon, 22 Aug 2022 07:32:24 +0000 Subject: [PATCH] member_game_setting, member_settlement_setting are added --- src/main.rs | 10 + src/member_game_setting/mod.rs | 1 + src/member_game_setting/service.rs | 594 ++++++++++++++++++++++ src/member_settlement_setting/mod.rs | 1 + src/member_settlement_setting/service.rs | 608 +++++++++++++++++++++++ 5 files changed, 1214 insertions(+) create mode 100644 src/member_game_setting/mod.rs create mode 100644 src/member_game_setting/service.rs create mode 100644 src/member_settlement_setting/mod.rs create mode 100644 src/member_settlement_setting/service.rs diff --git a/src/main.rs b/src/main.rs index 2c5d386..e90bea4 100644 --- a/src/main.rs +++ b/src/main.rs @@ -7,8 +7,10 @@ mod member_bank_account; mod member_bank_deposit; mod member_bank_withdraw; mod member_class; +mod member_game_setting; mod member_level; mod member_referrer; +mod member_settlement_setting; mod site; mod api; @@ -40,10 +42,16 @@ async fn main() -> Result<(), Box> { member_bank_withdraw::service::Service::new(connection_broker.clone(), queue_broker.clone()); let member_class_service = member_class::service::Service::new(connection_broker.clone(), queue_broker.clone()); + let member_game_setting_service = + member_game_setting::service::Service::new(connection_broker.clone(), queue_broker.clone()); let member_level_service = member_level::service::Service::new(connection_broker.clone(), queue_broker.clone()); let member_referrer_service = member_referrer::service::Service::new(connection_broker.clone(), queue_broker.clone()); + let member_settlement_setting_service = member_settlement_setting::service::Service::new( + connection_broker.clone(), + queue_broker.clone(), + ); let site_service = site::service::Service::new(connection_broker.clone(), queue_broker.clone()); let api_vendor_service = @@ -61,8 +69,10 @@ async fn main() -> Result<(), Box> { member_bank_deposit_service.subscribe(), member_bank_withdraw_service.subscribe(), member_class_service.subscribe(), + member_game_setting_service.subscribe(), member_level_service.subscribe(), member_referrer_service.subscribe(), + member_settlement_setting_service.subscribe(), site_service.subscribe(), api_vendor_service.subscribe(), api_game_service.subscribe(), diff --git a/src/member_game_setting/mod.rs b/src/member_game_setting/mod.rs new file mode 100644 index 0000000..1f278a4 --- /dev/null +++ b/src/member_game_setting/mod.rs @@ -0,0 +1 @@ +pub mod service; diff --git a/src/member_game_setting/service.rs b/src/member_game_setting/service.rs new file mode 100644 index 0000000..77407b2 --- /dev/null +++ b/src/member_game_setting/service.rs @@ -0,0 +1,594 @@ +use beteran_common_rust as bcr; +use beteran_protobuf_rust as bpr; +use prost::Message; + +/// +pub struct Service { + connection_broker: nats::asynk::Connection, + queue_broker: String, +} + +impl std::fmt::Debug for Service { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("beteran-backend-server-edge::member_game_setting::service::Service") + .finish() + } +} + +impl Service { + /// + pub fn new(connection_broker: nats::asynk::Connection, queue_broker: String) -> Service { + Service { + connection_broker, + queue_broker, + } + } + + pub async fn subscribe(&self) -> std::result::Result<(), std::boxed::Box> { + futures::try_join!( + self.create_member_game_setting(), + self.list_member_game_settings(), + self.get_member_game_setting(), + self.update_member_game_setting(), + self.delete_member_game_setting(), + ) + .map(|_| ()) + } + + fn get_client_in_header( + &self, + message: &nats::asynk::Message, + ) -> Result { + match &message.headers { + Some(headers) => { + let client = match headers.get(bpr::c2se::core::network::HEADER_CLIENT) { + Some(c) => { + let msg = base64::decode(c).map_err(|e| { + bcr::error::rpc::Error::Parse(bcr::error::rpc::Parse { + message: format!("invalid header: {}", e), + }) + })?; + bpr::models::core::network::Client::decode(msg.as_slice()).map_err(|e| { + bcr::error::rpc::Error::Parse(bcr::error::rpc::Parse { + message: format!("invalid header: {}", e), + }) + })? + } + None => { + return Err(bcr::error::rpc::Error::Parse(bcr::error::rpc::Parse { + message: "invalid client information".to_string(), + })); + } + }; + + Ok(client) + } + None => Err(bcr::error::rpc::Error::Parse(bcr::error::rpc::Parse { + message: "invalid header".to_string(), + })), + } + } + + async fn create_member_game_setting(&self) -> Result<(), Box> { + let s = self + .connection_broker + .queue_subscribe( + bpr::c2se::backend::member_game_setting::SUBJECT_CREATE_MEMBER_GAME_SETTING, + self.queue_broker.as_str(), + ) + .await?; + + while let Some(message) = s.next().await { + if let Err(e) = async { + let client = self.get_client_in_header(&message)?; + + let req = bpr::c2se::member_game_setting::CreateMemberGameSettingRequest::decode( + message.data.as_slice(), + ) + .map_err(|e| { + bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest { + message: format!("invalid request: {}", e), + }) + })?; + + let ss_create_member_game_setting_req = + bpr::ss::member_game_setting::CreateMemberGameSettingRequest { + client: Some(client), + request: Some( + bpr::ss::member_game_setting::create_member_game_setting_request::Request { + member_id: req.member_id, + }, + ), + }; + + let ss_create_member_game_setting_res_msg = self + .connection_broker + .request( + bpr::ss::member_game_setting::SUBJECT_CREATE_MEMBER_GAME_SETTING, + ss_create_member_game_setting_req.encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + let ss_create_member_game_setting_res = + bpr::ss::member_game_setting::CreateMemberGameSettingResponse::decode( + ss_create_member_game_setting_res_msg.data.as_slice(), + ) + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + if let Some(e) = ss_create_member_game_setting_res.error { + return Err(bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + })); + } + + if let Some(r) = ss_create_member_game_setting_res.result { + message + .respond( + bpr::c2se::member_game_setting::CreateMemberGameSettingResponse { + error: None, + result: Some( + bpr::c2se::member_game_setting::create_member_game_setting_response::Result { + member_game_setting: r.member_game_setting, + }, + ), + } + .encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + } + + Ok::<(), bcr::error::rpc::Error>(()) + } + .await + { + message + .respond( + bpr::c2se::member_game_setting::CreateMemberGameSettingResponse { + error: Some(bpr::protobuf::rpc::Error::from(e)), + result: None, + } + .encode_to_vec(), + ) + .await?; + } + } + + Ok(()) + } + + async fn list_member_game_settings(&self) -> Result<(), Box> { + let s = self + .connection_broker + .queue_subscribe( + bpr::c2se::backend::member_game_setting::SUBJECT_LIST_MEMBER_GAME_SETTINGS, + self.queue_broker.as_str(), + ) + .await?; + + while let Some(message) = s.next().await { + if let Err(e) = async { + let client = self.get_client_in_header(&message)?; + + let req = bpr::c2se::member_game_setting::ListMemberGameSettingsRequest::decode(message.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest { + message: format!("invalid request: {}", e), + }) + })?; + + let ss_list_member_game_settings_req = bpr::ss::member_game_setting::ListMemberGameSettingsRequest { + client: Some(client), + request: Some(bpr::ss::member_game_setting::list_member_game_settings_request::Request { + pagination: req.pagination, + sorts: req.sorts, + search: match req.search { + Some(s) => Some(bpr::ss::member_game_setting::list_member_game_settings_request::request::Search{ + member_id: s.member_id, + }), + None => None, + } + + }) + + }; + + let ss_list_member_game_settings_res_msg = self + .connection_broker + .request( + bpr::ss::member_game_setting::SUBJECT_LIST_MEMBER_GAME_SETTINGS, + ss_list_member_game_settings_req.encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + let ss_list_member_game_settings_res = + bpr::ss::member_game_setting::ListMemberGameSettingsResponse::decode(ss_list_member_game_settings_res_msg.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + if let Some(e) = ss_list_member_game_settings_res.error { + return Err(bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + })); + } + + if let Some(r) = ss_list_member_game_settings_res.result { + message + .respond( + bpr::c2se::member_game_setting::ListMemberGameSettingsResponse { + error: None, + result: Some(bpr::c2se::member_game_setting::list_member_game_settings_response::Result { + member_game_settings: r.member_game_settings, + }), + } + .encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + } + + Ok::<(), bcr::error::rpc::Error>(()) + } + .await + { + message + .respond( + bpr::c2se::member_game_setting::ListMemberGameSettingsResponse { + error: Some(bpr::protobuf::rpc::Error::from(e)), + result: None, + } + .encode_to_vec(), + ) + .await?; + } + } + + Ok(()) + } + + async fn get_member_game_setting(&self) -> Result<(), Box> { + let s = self + .connection_broker + .queue_subscribe( + bpr::c2se::backend::member_game_setting::SUBJECT_GET_MEMBER_GAME_SETTING, + self.queue_broker.as_str(), + ) + .await?; + + while let Some(message) = s.next().await { + if let Err(e) = async { + let client = self.get_client_in_header(&message)?; + + let req = bpr::c2se::member_game_setting::GetMemberGameSettingRequest::decode(message.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest { + message: format!("invalid request: {}", e), + }) + })?; + + let ss_get_member_game_setting_req = bpr::ss::member_game_setting::GetMemberGameSettingRequest { + client: Some(client), + request: Some(bpr::ss::member_game_setting::get_member_game_setting_request::Request{ + id: req.id, + }) + }; + + let ss_get_member_game_setting_res_msg = self + .connection_broker + .request( + bpr::ss::member_game_setting::SUBJECT_GET_MEMBER_GAME_SETTING, + ss_get_member_game_setting_req.encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + let ss_get_member_game_setting_res = + bpr::ss::member_game_setting::GetMemberGameSettingResponse::decode(ss_get_member_game_setting_res_msg.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + if let Some(e) = ss_get_member_game_setting_res.error { + return Err(bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + })); + } + + if let Some(r) = ss_get_member_game_setting_res.result { + message + .respond( + bpr::c2se::member_game_setting::GetMemberGameSettingResponse { + error: None, + result: Some(bpr::c2se::member_game_setting::get_member_game_setting_response::Result { member_game_setting: r.member_game_setting }), + } + .encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + } + + Ok::<(), bcr::error::rpc::Error>(()) + } + .await + { + message + .respond( + bpr::c2se::member_game_setting::GetMemberGameSettingResponse { + error: Some(bpr::protobuf::rpc::Error::from(e)), + result: None, + } + .encode_to_vec(), + ) + .await?; + } + } + + Ok(()) + } + + async fn update_member_game_setting(&self) -> Result<(), Box> { + let s = self + .connection_broker + .queue_subscribe( + bpr::c2se::backend::member_game_setting::SUBJECT_UPDATE_MEMBER_GAME_SETTING, + self.queue_broker.as_str(), + ) + .await?; + + while let Some(message) = s.next().await { + if let Err(e) = async { + let client = self.get_client_in_header(&message)?; + + let req = bpr::c2se::member_game_setting::UpdateMemberGameSettingRequest::decode(message.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest { + message: format!("invalid request: {}", e), + }) + })?; + + let ss_update_member_game_setting_req = bpr::ss::member_game_setting::UpdateMemberGameSettingRequest { + client: Some(client), + request: Some(bpr::ss::member_game_setting::update_member_game_setting_request::Request{ + id: req.id, + can_bet_casino: req.can_bet_casino, + can_bet_slot: req.can_bet_slot, + can_bet_powerball: req.can_bet_powerball, + can_bet_powerladder: req.can_bet_powerladder, + can_bet_eos: req.can_bet_eos, + can_bet_bogglepowerball: req.can_bet_bogglepowerball, + }) + }; + + let ss_update_member_game_setting_res_msg = self + .connection_broker + .request( + bpr::ss::member_game_setting::SUBJECT_UPDATE_MEMBER_GAME_SETTING, + ss_update_member_game_setting_req.encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + let ss_update_member_game_setting_res = bpr::ss::member_game_setting::UpdateMemberGameSettingResponse::decode( + ss_update_member_game_setting_res_msg.data.as_slice(), + ) + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + if let Some(e) = ss_update_member_game_setting_res.error { + return Err(bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + })); + } + + if let Some(r) = ss_update_member_game_setting_res.result { + message + .respond( + bpr::c2se::member_game_setting::UpdateMemberGameSettingResponse { + error: None, + result: Some(bpr::c2se::member_game_setting::update_member_game_setting_response::Result { + member_game_setting: r.member_game_setting, + }), + } + .encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + } + + Ok::<(), bcr::error::rpc::Error>(()) + } + .await + { + message + .respond( + bpr::c2se::member_game_setting::UpdateMemberGameSettingResponse { + error: Some(bpr::protobuf::rpc::Error::from(e)), + result: None, + } + .encode_to_vec(), + ) + .await?; + } + } + + Ok(()) + } + + async fn delete_member_game_setting(&self) -> Result<(), Box> { + let s = self + .connection_broker + .queue_subscribe( + bpr::c2se::backend::member_game_setting::SUBJECT_DELETE_MEMBER_GAME_SETTING, + self.queue_broker.as_str(), + ) + .await?; + + while let Some(message) = s.next().await { + if let Err(e) = async { + let client = self.get_client_in_header(&message)?; + + let req = bpr::c2se::member_game_setting::DeleteMemberGameSettingRequest::decode(message.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest { + message: format!("invalid request: {}", e), + }) + })?; + + let ss_delete_member_game_setting_req = bpr::ss::member_game_setting::DeleteMemberGameSettingRequest { + client: Some(client), + request: Some(bpr::ss::member_game_setting::delete_member_game_setting_request::Request { + id: req.id, + }) + + }; + + let ss_delete_member_game_setting_res_msg = self + .connection_broker + .request( + bpr::ss::member_game_setting::SUBJECT_DELETE_MEMBER_GAME_SETTING, + ss_delete_member_game_setting_req.encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + let ss_delete_member_game_setting_res = bpr::ss::member_game_setting::DeleteMemberGameSettingResponse::decode( + ss_delete_member_game_setting_res_msg.data.as_slice(), + ) + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + if let Some(e) = ss_delete_member_game_setting_res.error { + return Err(bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + })); + } + + if let Some(r) = ss_delete_member_game_setting_res.result { + message + .respond( + bpr::c2se::member_game_setting::DeleteMemberGameSettingResponse { + error: None, + result: Some(bpr::c2se::member_game_setting::delete_member_game_setting_response::Result {}), + } + .encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + } + + Ok::<(), bcr::error::rpc::Error>(()) + } + .await + { + message + .respond( + bpr::c2se::member_game_setting::DeleteMemberGameSettingResponse { + error: Some(bpr::protobuf::rpc::Error::from(e)), + result: None, + } + .encode_to_vec(), + ) + .await?; + } + } + + Ok(()) + } +} diff --git a/src/member_settlement_setting/mod.rs b/src/member_settlement_setting/mod.rs new file mode 100644 index 0000000..1f278a4 --- /dev/null +++ b/src/member_settlement_setting/mod.rs @@ -0,0 +1 @@ +pub mod service; diff --git a/src/member_settlement_setting/service.rs b/src/member_settlement_setting/service.rs new file mode 100644 index 0000000..b0e34c4 --- /dev/null +++ b/src/member_settlement_setting/service.rs @@ -0,0 +1,608 @@ +use beteran_common_rust as bcr; +use beteran_protobuf_rust as bpr; +use prost::Message; + +/// +pub struct Service { + connection_broker: nats::asynk::Connection, + queue_broker: String, +} + +impl std::fmt::Debug for Service { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + f.debug_struct("beteran-backend-server-edge::member_settlement_setting::service::Service") + .finish() + } +} + +impl Service { + /// + pub fn new(connection_broker: nats::asynk::Connection, queue_broker: String) -> Service { + Service { + connection_broker, + queue_broker, + } + } + + pub async fn subscribe(&self) -> std::result::Result<(), std::boxed::Box> { + futures::try_join!( + self.create_member_settlement_setting(), + self.list_member_settlement_settings(), + self.get_member_settlement_setting(), + self.update_member_settlement_setting(), + self.delete_member_settlement_setting(), + ) + .map(|_| ()) + } + + fn get_client_in_header( + &self, + message: &nats::asynk::Message, + ) -> Result { + match &message.headers { + Some(headers) => { + let client = match headers.get(bpr::c2se::core::network::HEADER_CLIENT) { + Some(c) => { + let msg = base64::decode(c).map_err(|e| { + bcr::error::rpc::Error::Parse(bcr::error::rpc::Parse { + message: format!("invalid header: {}", e), + }) + })?; + bpr::models::core::network::Client::decode(msg.as_slice()).map_err(|e| { + bcr::error::rpc::Error::Parse(bcr::error::rpc::Parse { + message: format!("invalid header: {}", e), + }) + })? + } + None => { + return Err(bcr::error::rpc::Error::Parse(bcr::error::rpc::Parse { + message: "invalid client information".to_string(), + })); + } + }; + + Ok(client) + } + None => Err(bcr::error::rpc::Error::Parse(bcr::error::rpc::Parse { + message: "invalid header".to_string(), + })), + } + } + + async fn create_member_settlement_setting(&self) -> Result<(), Box> { + let s = self + .connection_broker + .queue_subscribe( + bpr::c2se::backend::member_settlement_setting::SUBJECT_CREATE_MEMBER_SETTLEMENT_SETTING, + self.queue_broker.as_str(), + ) + .await?; + + while let Some(message) = s.next().await { + if let Err(e) = async { + let client = self.get_client_in_header(&message)?; + + let req = bpr::c2se::member_settlement_setting::CreateMemberSettlementSettingRequest::decode( + message.data.as_slice(), + ) + .map_err(|e| { + bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest { + message: format!("invalid request: {}", e), + }) + })?; + + let ss_create_member_settlement_setting_req = + bpr::ss::member_settlement_setting::CreateMemberSettlementSettingRequest { + client: Some(client), + request: Some( + bpr::ss::member_settlement_setting::create_member_settlement_setting_request::Request { + member_id: req.member_id, + }, + ), + }; + + let ss_create_member_settlement_setting_res_msg = self + .connection_broker + .request( + bpr::ss::member_settlement_setting::SUBJECT_CREATE_MEMBER_SETTLEMENT_SETTING, + ss_create_member_settlement_setting_req.encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + let ss_create_member_settlement_setting_res = + bpr::ss::member_settlement_setting::CreateMemberSettlementSettingResponse::decode( + ss_create_member_settlement_setting_res_msg.data.as_slice(), + ) + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + if let Some(e) = ss_create_member_settlement_setting_res.error { + return Err(bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + })); + } + + if let Some(r) = ss_create_member_settlement_setting_res.result { + message + .respond( + bpr::c2se::member_settlement_setting::CreateMemberSettlementSettingResponse { + error: None, + result: Some( + bpr::c2se::member_settlement_setting::create_member_settlement_setting_response::Result { + member_settlement_setting: r.member_settlement_setting, + }, + ), + } + .encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + } + + Ok::<(), bcr::error::rpc::Error>(()) + } + .await + { + message + .respond( + bpr::c2se::member_settlement_setting::CreateMemberSettlementSettingResponse { + error: Some(bpr::protobuf::rpc::Error::from(e)), + result: None, + } + .encode_to_vec(), + ) + .await?; + } + } + + Ok(()) + } + + async fn list_member_settlement_settings(&self) -> Result<(), Box> { + let s = self + .connection_broker + .queue_subscribe( + bpr::c2se::backend::member_settlement_setting::SUBJECT_LIST_MEMBER_SETTLEMENT_SETTINGS, + self.queue_broker.as_str(), + ) + .await?; + + while let Some(message) = s.next().await { + if let Err(e) = async { + let client = self.get_client_in_header(&message)?; + + let req = bpr::c2se::member_settlement_setting::ListMemberSettlementSettingsRequest::decode(message.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest { + message: format!("invalid request: {}", e), + }) + })?; + + let ss_list_member_settlement_settings_req = bpr::ss::member_settlement_setting::ListMemberSettlementSettingsRequest { + client: Some(client), + request: Some(bpr::ss::member_settlement_setting::list_member_settlement_settings_request::Request { + pagination: req.pagination, + sorts: req.sorts, + search: match req.search { + Some(s) => Some(bpr::ss::member_settlement_setting::list_member_settlement_settings_request::request::Search{ + member_id: s.member_id, + }), + None => None, + } + + }) + + }; + + let ss_list_member_settlement_settings_res_msg = self + .connection_broker + .request( + bpr::ss::member_settlement_setting::SUBJECT_LIST_MEMBER_SETTLEMENT_SETTINGS, + ss_list_member_settlement_settings_req.encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + let ss_list_member_settlement_settings_res = + bpr::ss::member_settlement_setting::ListMemberSettlementSettingsResponse::decode(ss_list_member_settlement_settings_res_msg.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + if let Some(e) = ss_list_member_settlement_settings_res.error { + return Err(bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + })); + } + + if let Some(r) = ss_list_member_settlement_settings_res.result { + message + .respond( + bpr::c2se::member_settlement_setting::ListMemberSettlementSettingsResponse { + error: None, + result: Some(bpr::c2se::member_settlement_setting::list_member_settlement_settings_response::Result { + member_settlement_settings: r.member_settlement_settings, + }), + } + .encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + } + + Ok::<(), bcr::error::rpc::Error>(()) + } + .await + { + message + .respond( + bpr::c2se::member_settlement_setting::ListMemberSettlementSettingsResponse { + error: Some(bpr::protobuf::rpc::Error::from(e)), + result: None, + } + .encode_to_vec(), + ) + .await?; + } + } + + Ok(()) + } + + async fn get_member_settlement_setting(&self) -> Result<(), Box> { + let s = self + .connection_broker + .queue_subscribe( + bpr::c2se::backend::member_settlement_setting::SUBJECT_GET_MEMBER_SETTLEMENT_SETTING, + self.queue_broker.as_str(), + ) + .await?; + + while let Some(message) = s.next().await { + if let Err(e) = async { + let client = self.get_client_in_header(&message)?; + + let req = bpr::c2se::member_settlement_setting::GetMemberSettlementSettingRequest::decode(message.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest { + message: format!("invalid request: {}", e), + }) + })?; + + let ss_get_member_settlement_setting_req = bpr::ss::member_settlement_setting::GetMemberSettlementSettingRequest { + client: Some(client), + request: Some(bpr::ss::member_settlement_setting::get_member_settlement_setting_request::Request{ + id: req.id, + }) + }; + + let ss_get_member_settlement_setting_res_msg = self + .connection_broker + .request( + bpr::ss::member_settlement_setting::SUBJECT_GET_MEMBER_SETTLEMENT_SETTING, + ss_get_member_settlement_setting_req.encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + let ss_get_member_settlement_setting_res = + bpr::ss::member_settlement_setting::GetMemberSettlementSettingResponse::decode(ss_get_member_settlement_setting_res_msg.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + if let Some(e) = ss_get_member_settlement_setting_res.error { + return Err(bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + })); + } + + if let Some(r) = ss_get_member_settlement_setting_res.result { + message + .respond( + bpr::c2se::member_settlement_setting::GetMemberSettlementSettingResponse { + error: None, + result: Some(bpr::c2se::member_settlement_setting::get_member_settlement_setting_response::Result { member_settlement_setting: r.member_settlement_setting }), + } + .encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + } + + Ok::<(), bcr::error::rpc::Error>(()) + } + .await + { + message + .respond( + bpr::c2se::member_settlement_setting::GetMemberSettlementSettingResponse { + error: Some(bpr::protobuf::rpc::Error::from(e)), + result: None, + } + .encode_to_vec(), + ) + .await?; + } + } + + Ok(()) + } + + async fn update_member_settlement_setting(&self) -> Result<(), Box> { + let s = self + .connection_broker + .queue_subscribe( + bpr::c2se::backend::member_settlement_setting::SUBJECT_UPDATE_MEMBER_SETTLEMENT_SETTING, + self.queue_broker.as_str(), + ) + .await?; + + while let Some(message) = s.next().await { + if let Err(e) = async { + let client = self.get_client_in_header(&message)?; + + let req = bpr::c2se::member_settlement_setting::UpdateMemberSettlementSettingRequest::decode(message.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest { + message: format!("invalid request: {}", e), + }) + })?; + + let ss_update_member_settlement_setting_req = bpr::ss::member_settlement_setting::UpdateMemberSettlementSettingRequest { + client: Some(client), + request: Some(bpr::ss::member_settlement_setting::update_member_settlement_setting_request::Request{ + id: req.id, + can_exchange: req.can_exchange, + can_first_charge_comp: req.can_first_charge_comp, + can_per_charge_comp: req.can_per_charge_comp, + manual_payment_type_for_partner: req.manual_payment_type_for_partner, + settlement_type: req.settlement_type, + rate_casino: req.rate_casino, + rate_casino_loosing: req.rate_casino_loosing, + rate_casino_bacara: req.rate_casino_bacara, + rate_casino_roulette: req.rate_casino_roulette, + rate_casino_dragon_tiger: req.rate_casino_dragon_tiger, + rate_slot: req.rate_slot, + rate_slot_loosing: req.rate_slot_loosing, + rate_powerball_single: req.rate_powerball_single, + rate_powerball_combo: req.rate_powerball_combo, + rate_powerladder_single: req.rate_powerladder_single, + rate_powerladder_combo: req.rate_powerladder_combo, + rate_eos_single: req.rate_eos_single, + rate_eos_combo: req.rate_eos_combo, + rate_bogglepowerball_single: req.rate_bogglepowerball_single, + rate_bogglepowerball_combo: req.rate_bogglepowerball_combo, + }) + }; + + let ss_update_member_settlement_setting_res_msg = self + .connection_broker + .request( + bpr::ss::member_settlement_setting::SUBJECT_UPDATE_MEMBER_SETTLEMENT_SETTING, + ss_update_member_settlement_setting_req.encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + let ss_update_member_settlement_setting_res = bpr::ss::member_settlement_setting::UpdateMemberSettlementSettingResponse::decode( + ss_update_member_settlement_setting_res_msg.data.as_slice(), + ) + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + if let Some(e) = ss_update_member_settlement_setting_res.error { + return Err(bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + })); + } + + if let Some(r) = ss_update_member_settlement_setting_res.result { + message + .respond( + bpr::c2se::member_settlement_setting::UpdateMemberSettlementSettingResponse { + error: None, + result: Some(bpr::c2se::member_settlement_setting::update_member_settlement_setting_response::Result { + member_settlement_setting: r.member_settlement_setting, + }), + } + .encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + } + + Ok::<(), bcr::error::rpc::Error>(()) + } + .await + { + message + .respond( + bpr::c2se::member_settlement_setting::UpdateMemberSettlementSettingResponse { + error: Some(bpr::protobuf::rpc::Error::from(e)), + result: None, + } + .encode_to_vec(), + ) + .await?; + } + } + + Ok(()) + } + + async fn delete_member_settlement_setting(&self) -> Result<(), Box> { + let s = self + .connection_broker + .queue_subscribe( + bpr::c2se::backend::member_settlement_setting::SUBJECT_DELETE_MEMBER_SETTLEMENT_SETTING, + self.queue_broker.as_str(), + ) + .await?; + + while let Some(message) = s.next().await { + if let Err(e) = async { + let client = self.get_client_in_header(&message)?; + + let req = bpr::c2se::member_settlement_setting::DeleteMemberSettlementSettingRequest::decode(message.data.as_slice()) + .map_err(|e| { + bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest { + message: format!("invalid request: {}", e), + }) + })?; + + let ss_delete_member_settlement_setting_req = bpr::ss::member_settlement_setting::DeleteMemberSettlementSettingRequest { + client: Some(client), + request: Some(bpr::ss::member_settlement_setting::delete_member_settlement_setting_request::Request { + id: req.id, + }) + + }; + + let ss_delete_member_settlement_setting_res_msg = self + .connection_broker + .request( + bpr::ss::member_settlement_setting::SUBJECT_DELETE_MEMBER_SETTLEMENT_SETTING, + ss_delete_member_settlement_setting_req.encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + let ss_delete_member_settlement_setting_res = bpr::ss::member_settlement_setting::DeleteMemberSettlementSettingResponse::decode( + ss_delete_member_settlement_setting_res_msg.data.as_slice(), + ) + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + + if let Some(e) = ss_delete_member_settlement_setting_res.error { + return Err(bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + })); + } + + if let Some(r) = ss_delete_member_settlement_setting_res.result { + message + .respond( + bpr::c2se::member_settlement_setting::DeleteMemberSettlementSettingResponse { + error: None, + result: Some(bpr::c2se::member_settlement_setting::delete_member_settlement_setting_response::Result {}), + } + .encode_to_vec(), + ) + .await + .map_err(|e| { + bcr::error::rpc::Error::Server(bcr::error::rpc::Server { + code: bpr::protobuf::rpc::Error::SERVER_00, + message: format!("server {}", e), + data: None, + }) + })?; + } + + Ok::<(), bcr::error::rpc::Error>(()) + } + .await + { + message + .respond( + bpr::c2se::member_settlement_setting::DeleteMemberSettlementSettingResponse { + error: Some(bpr::protobuf::rpc::Error::from(e)), + result: None, + } + .encode_to_vec(), + ) + .await?; + } + } + + Ok(()) + } +}