cmd
docs
pkg
validation
.cargo
api
src
create.rs
create_mapfix.rs
create_submission.rs
main.rs
maptest.rs
message_handler.rs
nats_types.rs
rbx_util.rs
types.rs
upload_mapfix.rs
upload_submission.rs
validate_mapfix.rs
validate_submission.rs
validator.rs
.dockerignore
Cargo.toml
Containerfile
web
.drone.yml
.gitignore
Cargo.lock
Cargo.toml
Containerfile
LICENSE
Makefile
README.md
compose.yaml
generate.go
go.mod
go.sum
openapi-internal.yaml
openapi.yaml
60 lines
2.5 KiB
Rust
60 lines
2.5 KiB
Rust
#[allow(dead_code)]
|
|
#[derive(Debug)]
|
|
pub enum HandleMessageError{
|
|
Messages(async_nats::jetstream::consumer::pull::MessagesError),
|
|
DoubleAck(async_nats::Error),
|
|
Json(serde_json::Error),
|
|
UnknownSubject(String),
|
|
CreateMapfix(submissions_api::Error),
|
|
CreateSubmission(submissions_api::Error),
|
|
UploadMapfix(crate::upload_mapfix::Error),
|
|
UploadSubmission(crate::upload_submission::Error),
|
|
ValidateMapfix(crate::validate_mapfix::Error),
|
|
ValidateSubmission(crate::validate_submission::Error),
|
|
}
|
|
impl std::fmt::Display for HandleMessageError{
|
|
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
|
write!(f,"{self:?}")
|
|
}
|
|
}
|
|
impl std::error::Error for HandleMessageError{}
|
|
|
|
pub type MessageResult=Result<async_nats::jetstream::Message,async_nats::jetstream::consumer::pull::MessagesError>;
|
|
|
|
fn from_slice<'a,T:serde::de::Deserialize<'a>>(slice:&'a [u8])->Result<T,HandleMessageError>{
|
|
serde_json::from_slice(slice).map_err(HandleMessageError::Json)
|
|
}
|
|
|
|
pub struct MessageHandler{
|
|
pub(crate) cookie_context:rbx_asset::cookie::CookieContext,
|
|
pub(crate) group_id:Option<u64>,
|
|
pub(crate) api:submissions_api::internal::Context,
|
|
}
|
|
|
|
impl MessageHandler{
|
|
pub fn new(
|
|
cookie_context:rbx_asset::cookie::CookieContext,
|
|
group_id:Option<u64>,
|
|
api:submissions_api::internal::Context,
|
|
)->Self{
|
|
Self{
|
|
cookie_context,
|
|
group_id,
|
|
api,
|
|
}
|
|
}
|
|
pub async fn handle_message_result(&self,message_result:MessageResult)->Result<(),HandleMessageError>{
|
|
let message=message_result.map_err(HandleMessageError::Messages)?;
|
|
message.double_ack().await.map_err(HandleMessageError::DoubleAck)?;
|
|
match message.subject.as_str(){
|
|
"maptest.mapfixes.create"=>self.create_mapfix(from_slice(&message.payload)?).await.map_err(HandleMessageError::CreateMapfix),
|
|
"maptest.submissions.create"=>self.create_submission(from_slice(&message.payload)?).await.map_err(HandleMessageError::CreateSubmission),
|
|
"maptest.mapfixes.upload"=>self.upload_mapfix(from_slice(&message.payload)?).await.map_err(HandleMessageError::UploadMapfix),
|
|
"maptest.submissions.upload"=>self.upload_submission(from_slice(&message.payload)?).await.map_err(HandleMessageError::UploadSubmission),
|
|
"maptest.mapfixes.validate"=>self.validate_mapfix(from_slice(&message.payload)?).await.map_err(HandleMessageError::ValidateMapfix),
|
|
"maptest.submissions.validate"=>self.validate_submission(from_slice(&message.payload)?).await.map_err(HandleMessageError::ValidateSubmission),
|
|
other=>Err(HandleMessageError::UnknownSubject(other.to_owned()))
|
|
}
|
|
}
|
|
}
|