1197 lines
39 KiB
Rust
1197 lines
39 KiB
Rust
//!
|
|
//!
|
|
|
|
use std::str::FromStr;
|
|
|
|
use crate::compositions;
|
|
use crate::repositories;
|
|
use beteran_common_rust as bcr;
|
|
use beteran_protobuf_rust as bpr;
|
|
use diesel::{
|
|
r2d2::{ConnectionManager, Pool},
|
|
PgConnection,
|
|
};
|
|
use prost::Message;
|
|
|
|
///
|
|
pub struct Service {
|
|
connection_broker: nats::asynk::Connection,
|
|
queue_broker: String,
|
|
pool: Pool<ConnectionManager<PgConnection>>,
|
|
site_composition: compositions::site::composition::Composition,
|
|
member_referrer_repository: repositories::member_referrer::repository::Repository,
|
|
member_referrer_composition: compositions::member_referrer::composition::Composition,
|
|
}
|
|
|
|
impl std::fmt::Debug for Service {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
f.debug_struct("Service of service.member.service.identity")
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
impl Service {
|
|
///
|
|
pub fn new(
|
|
connection_broker: nats::asynk::Connection,
|
|
queue_broker: String,
|
|
pool: Pool<ConnectionManager<PgConnection>>,
|
|
) -> Service {
|
|
Service {
|
|
connection_broker,
|
|
queue_broker,
|
|
pool,
|
|
site_composition: compositions::site::composition::Composition::new(),
|
|
member_referrer_repository: repositories::member_referrer::repository::Repository::new(),
|
|
member_referrer_composition: compositions::member_referrer::composition::Composition::new(),
|
|
}
|
|
}
|
|
|
|
pub async fn subscribe(&self) -> std::result::Result<(), std::boxed::Box<dyn std::error::Error>> {
|
|
futures::try_join!(
|
|
self.create_member_referrer(),
|
|
self.create_member_referrers(),
|
|
self.list_member_referrers(),
|
|
self.get_member_referrer(),
|
|
self.get_member_referrer_by_code(),
|
|
self.update_member_referrer(),
|
|
self.delete_member_referrer(),
|
|
self.delete_member_referrers(),
|
|
)
|
|
.map(|_| ())
|
|
}
|
|
|
|
fn check_site(
|
|
&self,
|
|
conn: &diesel::PgConnection,
|
|
url: Option<String>,
|
|
site_id: uuid::Uuid,
|
|
) -> Result<repositories::site::models::Site, bcr::error::rpc::Error> {
|
|
match self
|
|
.site_composition
|
|
.select_by_url(conn, url, site_id)
|
|
.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,
|
|
})
|
|
})? {
|
|
Some(s) => Ok(s),
|
|
None => Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid site_url information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "client.site_url".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::None,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
)),
|
|
}
|
|
}
|
|
|
|
async fn create_member_referrer(&self) -> Result<(), Box<dyn std::error::Error>> {
|
|
let s = self
|
|
.connection_broker
|
|
.queue_subscribe(
|
|
bpr::ss::member_referrer::SUBJECT_CREATE_MEMBER_REFERRER,
|
|
self.queue_broker.as_str(),
|
|
)
|
|
.await?;
|
|
|
|
while let Some(message) = s.next().await {
|
|
if let Err(e) = async {
|
|
let req =
|
|
bpr::ss::member_referrer::CreateMemberReferrerRequest::decode(message.data.as_slice())
|
|
.map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest {
|
|
message: format!("invalid request: {}", e),
|
|
})
|
|
})?;
|
|
|
|
let client = match req.client {
|
|
Some(c) => c,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid client information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "client".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let request = match req.request {
|
|
Some(r) => r,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid request information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "request".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let member_id = uuid::Uuid::from_str(request.member_id.as_str()).map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidParams(bcr::error::rpc::InvalidParams {
|
|
message: "invalid member_id param".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "member_id".to_string(),
|
|
value: request.member_id.clone(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: e.to_string(),
|
|
},
|
|
})
|
|
})?;
|
|
|
|
let conn = self.pool.get().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 new_member_referrer =
|
|
repositories::member_referrer::models::NewMemberReferrer { member_id };
|
|
let s = self
|
|
.member_referrer_repository
|
|
.insert(&conn, &new_member_referrer)
|
|
.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 mr = self
|
|
.member_referrer_composition
|
|
.select(&conn, s)
|
|
.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,
|
|
})
|
|
})?;
|
|
|
|
message
|
|
.respond(
|
|
bpr::ss::member_referrer::CreateMemberReferrerResponse {
|
|
error: None,
|
|
result: Some(
|
|
bpr::ss::member_referrer::create_member_referrer_response::Result {
|
|
member_referrer: mr
|
|
.as_ref()
|
|
.map(bpr::models::member_referrer::MemberReferrerModel::from),
|
|
},
|
|
),
|
|
}
|
|
.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::ss::member_referrer::CreateMemberReferrerResponse {
|
|
error: Some(bpr::protobuf::rpc::Error::from(e)),
|
|
result: None,
|
|
}
|
|
.encode_to_vec(),
|
|
)
|
|
.await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn create_member_referrers(&self) -> Result<(), Box<dyn std::error::Error>> {
|
|
let s = self
|
|
.connection_broker
|
|
.queue_subscribe(
|
|
bpr::ss::member_referrer::SUBJECT_CREATE_MEMBER_REFERRERS,
|
|
self.queue_broker.as_str(),
|
|
)
|
|
.await?;
|
|
|
|
while let Some(message) = s.next().await {
|
|
if let Err(e) = async {
|
|
let req =
|
|
bpr::ss::member_referrer::CreateMemberReferrersRequest::decode(message.data.as_slice())
|
|
.map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest {
|
|
message: format!("invalid request: {}", e),
|
|
})
|
|
})?;
|
|
|
|
let client = match req.client {
|
|
Some(c) => c,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid client information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "client".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let request = match req.request {
|
|
Some(r) => r,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid request information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "request".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
|
|
let mut member_ids: Vec<uuid::Uuid> = vec![];
|
|
for i in request.member_ids {
|
|
let u = match uuid::Uuid::from_str(i.as_str()) {
|
|
Ok(u) => u,
|
|
Err(e) => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid member_ids param".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "member_ids".to_string(),
|
|
value: i.clone(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: e.to_string(),
|
|
},
|
|
},
|
|
))
|
|
}
|
|
};
|
|
member_ids.push(u);
|
|
}
|
|
|
|
let conn = self.pool.get().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 new_member_referrers: Vec<repositories::member_referrer::models::NewMemberReferrer> =
|
|
member_ids
|
|
.iter()
|
|
.map(
|
|
|member_id| repositories::member_referrer::models::NewMemberReferrer {
|
|
member_id: member_id.clone(),
|
|
},
|
|
)
|
|
.collect();
|
|
|
|
let s = self
|
|
.member_referrer_repository
|
|
.inserts(&conn, &new_member_referrers)
|
|
.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 mr = self
|
|
.member_referrer_composition
|
|
.selects(&conn, s)
|
|
.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,
|
|
})
|
|
})?;
|
|
|
|
message
|
|
.respond(
|
|
bpr::ss::member_referrer::CreateMemberReferrersResponse {
|
|
error: None,
|
|
result: Some(
|
|
bpr::ss::member_referrer::create_member_referrers_response::Result {
|
|
member_referrers: mr
|
|
.iter()
|
|
.map(bpr::models::member_referrer::MemberReferrerModel::from)
|
|
.collect(),
|
|
},
|
|
),
|
|
}
|
|
.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::ss::member_referrer::CreateMemberReferrersResponse {
|
|
error: Some(bpr::protobuf::rpc::Error::from(e)),
|
|
result: None,
|
|
}
|
|
.encode_to_vec(),
|
|
)
|
|
.await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn list_member_referrers(&self) -> Result<(), Box<dyn std::error::Error>> {
|
|
let s = self
|
|
.connection_broker
|
|
.queue_subscribe(
|
|
bpr::ss::member_referrer::SUBJECT_LIST_MEMBER_REFERRERS,
|
|
self.queue_broker.as_str(),
|
|
)
|
|
.await?;
|
|
|
|
while let Some(message) = s.next().await {
|
|
if let Err(e) = async {
|
|
let req =
|
|
bpr::ss::member_referrer::ListMemberReferrersRequest::decode(message.data.as_slice())
|
|
.map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest {
|
|
message: format!("invalid request: {}", e),
|
|
})
|
|
})?;
|
|
|
|
let client = match req.client {
|
|
Some(c) => c,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid client information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "client".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let request = match req.request {
|
|
Some(r) => r,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid request information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "request".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let search = match request.search {
|
|
Some(s) => {
|
|
let member_id = match s.member_id {
|
|
Some(d) => match uuid::Uuid::from_str(d.as_str()) {
|
|
Ok(dd) => Some(dd),
|
|
Err(e) => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid member_id param".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "member_id".to_string(),
|
|
value: d.clone(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: e.to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
},
|
|
None => None,
|
|
};
|
|
|
|
Some(repositories::member_referrer::models::FindAllSearch {
|
|
member_id,
|
|
can_use: s.can_use,
|
|
memo_like: s.memo_like,
|
|
})
|
|
}
|
|
None => None,
|
|
};
|
|
|
|
let conn = self.pool.get().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 find_all = repositories::member_referrer::models::FindAll {
|
|
search,
|
|
pagination: request
|
|
.pagination
|
|
.as_ref()
|
|
.map(bcr::pagination::Pagination::from),
|
|
sorts: Some(
|
|
request
|
|
.sorts
|
|
.iter()
|
|
.map(bcr::pagination::Sort::from)
|
|
.collect(),
|
|
),
|
|
};
|
|
|
|
let count = self
|
|
.member_referrer_repository
|
|
.select_all_count(&conn, &find_all)
|
|
.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 list = self
|
|
.member_referrer_composition
|
|
.select_all(&conn, &find_all)
|
|
.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,
|
|
})
|
|
})?;
|
|
|
|
message
|
|
.respond(
|
|
bpr::ss::member_referrer::ListMemberReferrersResponse {
|
|
error: None,
|
|
result: Some(
|
|
bpr::ss::member_referrer::list_member_referrers_response::Result {
|
|
member_referrers: list
|
|
.iter()
|
|
.map(|d| bpr::models::member_referrer::MemberReferrerModel::from(d))
|
|
.collect(),
|
|
},
|
|
),
|
|
}
|
|
.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::ss::member_referrer::ListMemberReferrersResponse {
|
|
error: Some(bpr::protobuf::rpc::Error::from(e)),
|
|
result: None,
|
|
}
|
|
.encode_to_vec(),
|
|
)
|
|
.await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn get_member_referrer(&self) -> Result<(), Box<dyn std::error::Error>> {
|
|
let s = self
|
|
.connection_broker
|
|
.queue_subscribe(
|
|
bpr::ss::member_referrer::SUBJECT_GET_MEMBER_REFERRER,
|
|
self.queue_broker.as_str(),
|
|
)
|
|
.await?;
|
|
|
|
while let Some(message) = s.next().await {
|
|
if let Err(e) = async {
|
|
let req =
|
|
bpr::ss::member_referrer::GetMemberReferrerRequest::decode(message.data.as_slice())
|
|
.map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest {
|
|
message: format!("invalid request: {}", e),
|
|
})
|
|
})?;
|
|
let client = match req.client {
|
|
Some(c) => c,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid client information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "client".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let request = match req.request {
|
|
Some(r) => r,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid request information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "request".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let id = uuid::Uuid::from_str(request.id.as_str()).map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidParams(bcr::error::rpc::InvalidParams {
|
|
message: "invalid id param".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "id".to_string(),
|
|
value: request.id.clone(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: e.to_string(),
|
|
},
|
|
})
|
|
})?;
|
|
|
|
let conn = self.pool.get().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 s = self
|
|
.member_referrer_composition
|
|
.select(&conn, id)
|
|
.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,
|
|
})
|
|
})?;
|
|
|
|
message
|
|
.respond(
|
|
bpr::ss::member_referrer::GetMemberReferrerResponse {
|
|
error: None,
|
|
result: Some(
|
|
bpr::ss::member_referrer::get_member_referrer_response::Result {
|
|
member_referrer: s
|
|
.map(|d| bpr::models::member_referrer::MemberReferrerModel::from(&d)),
|
|
},
|
|
),
|
|
}
|
|
.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::ss::member_referrer::GetMemberReferrerResponse {
|
|
error: Some(bpr::protobuf::rpc::Error::from(e)),
|
|
result: None,
|
|
}
|
|
.encode_to_vec(),
|
|
)
|
|
.await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn get_member_referrer_by_code(&self) -> Result<(), Box<dyn std::error::Error>> {
|
|
let s = self
|
|
.connection_broker
|
|
.queue_subscribe(
|
|
bpr::ss::member_referrer::SUBJECT_GET_MEMBER_REFERRER_BY_CODE,
|
|
self.queue_broker.as_str(),
|
|
)
|
|
.await?;
|
|
|
|
while let Some(message) = s.next().await {
|
|
if let Err(e) = async {
|
|
let req =
|
|
bpr::ss::member_referrer::GetMemberReferrerByCodeRequest::decode(message.data.as_slice())
|
|
.map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest {
|
|
message: format!("invalid request: {}", e),
|
|
})
|
|
})?;
|
|
let client = match req.client {
|
|
Some(c) => c,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid client information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "client".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let request = match req.request {
|
|
Some(r) => r,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid request information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "request".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
|
|
let conn = self.pool.get().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 s = self
|
|
.member_referrer_composition
|
|
.select_by_username(&conn, &request.code)
|
|
.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,
|
|
})
|
|
})?;
|
|
|
|
message
|
|
.respond(
|
|
bpr::ss::member_referrer::GetMemberReferrerByCodeResponse {
|
|
error: None,
|
|
result: Some(
|
|
bpr::ss::member_referrer::get_member_referrer_by_code_response::Result {
|
|
member_referrer: s
|
|
.map(|d| bpr::models::member_referrer::MemberReferrerModel::from(&d)),
|
|
},
|
|
),
|
|
}
|
|
.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::ss::member_referrer::GetMemberReferrerByCodeResponse {
|
|
error: Some(bpr::protobuf::rpc::Error::from(e)),
|
|
result: None,
|
|
}
|
|
.encode_to_vec(),
|
|
)
|
|
.await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn update_member_referrer(&self) -> Result<(), Box<dyn std::error::Error>> {
|
|
let s = self
|
|
.connection_broker
|
|
.queue_subscribe(
|
|
bpr::ss::member_referrer::SUBJECT_UPDATE_MEMBER_REFERRER,
|
|
self.queue_broker.as_str(),
|
|
)
|
|
.await?;
|
|
|
|
while let Some(message) = s.next().await {
|
|
if let Err(e) = async {
|
|
let req =
|
|
bpr::ss::member_referrer::UpdateMemberReferrerRequest::decode(message.data.as_slice())
|
|
.map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest {
|
|
message: format!("invalid request: {}", e),
|
|
})
|
|
})?;
|
|
let client = match req.client {
|
|
Some(c) => c,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid client information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "client".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let request = match req.request {
|
|
Some(r) => r,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid request information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "request".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let id = uuid::Uuid::from_str(request.id.as_str()).map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidParams(bcr::error::rpc::InvalidParams {
|
|
message: "invalid id param".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "id".to_string(),
|
|
value: request.id.clone(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: e.to_string(),
|
|
},
|
|
})
|
|
})?;
|
|
|
|
let conn = self.pool.get().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 modify_member_referrer = repositories::member_referrer::models::ModifyMemberReferrer {
|
|
can_use: request.can_use,
|
|
memo: request.memo,
|
|
};
|
|
|
|
let _affected = self
|
|
.member_referrer_repository
|
|
.update(&conn, id, &modify_member_referrer)
|
|
.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 s = self
|
|
.member_referrer_composition
|
|
.select(&conn, id)
|
|
.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,
|
|
})
|
|
})?;
|
|
|
|
message
|
|
.respond(
|
|
bpr::ss::member_referrer::UpdateMemberReferrerResponse {
|
|
error: None,
|
|
result: Some(
|
|
bpr::ss::member_referrer::update_member_referrer_response::Result {
|
|
member_referrer: s
|
|
.map(|d| bpr::models::member_referrer::MemberReferrerModel::from(&d)),
|
|
},
|
|
),
|
|
}
|
|
.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::ss::member_referrer::UpdateMemberReferrerResponse {
|
|
error: Some(bpr::protobuf::rpc::Error::from(e)),
|
|
result: None,
|
|
}
|
|
.encode_to_vec(),
|
|
)
|
|
.await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete_member_referrer(&self) -> Result<(), Box<dyn std::error::Error>> {
|
|
let s = self
|
|
.connection_broker
|
|
.queue_subscribe(
|
|
bpr::ss::member_referrer::SUBJECT_DELETE_MEMBER_REFERRER,
|
|
self.queue_broker.as_str(),
|
|
)
|
|
.await?;
|
|
|
|
while let Some(message) = s.next().await {
|
|
if let Err(e) = async {
|
|
let req =
|
|
bpr::ss::member_referrer::DeleteMemberReferrerRequest::decode(message.data.as_slice())
|
|
.map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest {
|
|
message: format!("invalid request: {}", e),
|
|
})
|
|
})?;
|
|
let client = match req.client {
|
|
Some(c) => c,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid client information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "client".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let request = match req.request {
|
|
Some(r) => r,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid request information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "request".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let id = uuid::Uuid::from_str(request.id.as_str()).map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidParams(bcr::error::rpc::InvalidParams {
|
|
message: "invalid id param".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "id".to_string(),
|
|
value: request.id.clone(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: e.to_string(),
|
|
},
|
|
})
|
|
})?;
|
|
|
|
let conn = self.pool.get().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 _affected = self
|
|
.member_referrer_repository
|
|
.delete(&conn, id)
|
|
.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,
|
|
})
|
|
})?;
|
|
|
|
message
|
|
.respond(
|
|
bpr::ss::member_referrer::DeleteMemberReferrerResponse {
|
|
error: None,
|
|
result: Some(bpr::ss::member_referrer::delete_member_referrer_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::ss::member_referrer::DeleteMemberReferrerResponse {
|
|
error: Some(bpr::protobuf::rpc::Error::from(e)),
|
|
result: None,
|
|
}
|
|
.encode_to_vec(),
|
|
)
|
|
.await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn delete_member_referrers(&self) -> Result<(), Box<dyn std::error::Error>> {
|
|
let s = self
|
|
.connection_broker
|
|
.queue_subscribe(
|
|
bpr::ss::member_referrer::SUBJECT_DELETE_MEMBER_REFERRERS,
|
|
self.queue_broker.as_str(),
|
|
)
|
|
.await?;
|
|
|
|
while let Some(message) = s.next().await {
|
|
if let Err(e) = async {
|
|
let req =
|
|
bpr::ss::member_referrer::DeleteMemberReferrersRequest::decode(message.data.as_slice())
|
|
.map_err(|e| {
|
|
bcr::error::rpc::Error::InvalidRequest(bcr::error::rpc::InvalidRequest {
|
|
message: format!("invalid request: {}", e),
|
|
})
|
|
})?;
|
|
let client = match req.client {
|
|
Some(c) => c,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid client information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "client".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
let request = match req.request {
|
|
Some(r) => r,
|
|
None => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid request information".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "request".to_string(),
|
|
value: "".to_string(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: "".to_string(),
|
|
},
|
|
},
|
|
));
|
|
}
|
|
};
|
|
|
|
let mut ids: Vec<uuid::Uuid> = vec![];
|
|
for i in request.ids {
|
|
let u = match uuid::Uuid::from_str(i.as_str()) {
|
|
Ok(u) => u,
|
|
Err(e) => {
|
|
return Err(bcr::error::rpc::Error::InvalidParams(
|
|
bcr::error::rpc::InvalidParams {
|
|
message: "invalid ids param".to_string(),
|
|
detail: bcr::error::rpc::InvalidParamsDetail {
|
|
location: "request".to_string(),
|
|
param: "ids".to_string(),
|
|
value: i.clone(),
|
|
error_type: bcr::error::rpc::InvalidParamsType::Required,
|
|
message: e.to_string(),
|
|
},
|
|
},
|
|
))
|
|
}
|
|
};
|
|
ids.push(u);
|
|
}
|
|
|
|
let conn = self.pool.get().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 _affected = self
|
|
.member_referrer_repository
|
|
.deletes(&conn, ids)
|
|
.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,
|
|
})
|
|
})?;
|
|
|
|
message
|
|
.respond(
|
|
bpr::ss::member_referrer::DeleteMemberReferrersResponse {
|
|
error: None,
|
|
result: Some(bpr::ss::member_referrer::delete_member_referrers_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::ss::member_referrer::DeleteMemberReferrersResponse {
|
|
error: Some(bpr::protobuf::rpc::Error::from(e)),
|
|
result: None,
|
|
}
|
|
.encode_to_vec(),
|
|
)
|
|
.await?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|