252 lines
9.6 KiB
Rust
252 lines
9.6 KiB
Rust
use super::*;
|
|
use std::collections::HashMap;
|
|
|
|
pub type BarkBattleDraftCreateRecordInput = BarkBattleDraftCreateInput;
|
|
pub type BarkBattleDraftConfigUpsertRecordInput = BarkBattleDraftConfigUpsertInput;
|
|
pub type BarkBattleWorkPublishRecordInput = BarkBattleWorkPublishInput;
|
|
pub type BarkBattleRunStartRecordInput = BarkBattleRunStartInput;
|
|
pub type BarkBattleRunFinishRecordInput = BarkBattleRunFinishInput;
|
|
|
|
impl SpacetimeClient {
|
|
pub async fn create_bark_battle_draft(
|
|
&self,
|
|
input: BarkBattleDraftCreateRecordInput,
|
|
) -> Result<BarkBattleDraftConfigRecord, SpacetimeClientError> {
|
|
self.call_after_connect("create_bark_battle_draft", move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.create_bark_battle_draft_then(input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_bark_battle_draft_config_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn update_bark_battle_draft_config(
|
|
&self,
|
|
input: BarkBattleDraftConfigUpsertRecordInput,
|
|
) -> Result<BarkBattleDraftConfigRecord, SpacetimeClientError> {
|
|
self.call_after_connect(
|
|
"update_bark_battle_draft_config",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.update_bark_battle_draft_config_then(input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_bark_battle_draft_config_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn get_bark_battle_draft_config(
|
|
&self,
|
|
draft_id: String,
|
|
owner_user_id: String,
|
|
) -> Result<BarkBattleDraftConfigRecord, SpacetimeClientError> {
|
|
self.read_after_connect("get_bark_battle_draft_config", move |connection| {
|
|
let row = connection
|
|
.db()
|
|
.bark_battle_draft_config()
|
|
.draft_id()
|
|
.find(&draft_id)
|
|
.ok_or_else(|| {
|
|
SpacetimeClientError::procedure_failed(Some(
|
|
"bark_battle draft 不存在".to_string(),
|
|
))
|
|
})?;
|
|
if row.owner_user_id != owner_user_id {
|
|
return Err(SpacetimeClientError::procedure_failed(Some(
|
|
"bark_battle draft owner 不匹配".to_string(),
|
|
)));
|
|
}
|
|
Ok(map_bark_battle_draft_config_row(row))
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn publish_bark_battle_work(
|
|
&self,
|
|
input: BarkBattleWorkPublishRecordInput,
|
|
) -> Result<BarkBattleRuntimeConfigRecord, SpacetimeClientError> {
|
|
self.call_after_connect("publish_bark_battle_work", move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.publish_bark_battle_work_then(input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_bark_battle_runtime_config_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn get_bark_battle_runtime_config(
|
|
&self,
|
|
work_id: String,
|
|
owner_user_id: Option<String>,
|
|
) -> Result<BarkBattleRuntimeConfigRecord, SpacetimeClientError> {
|
|
let input = BarkBattleRuntimeConfigGetInput {
|
|
work_id,
|
|
owner_user_id,
|
|
};
|
|
self.call_after_connect(
|
|
"get_bark_battle_runtime_config",
|
|
move |connection, sender| {
|
|
connection.procedures().get_bark_battle_runtime_config_then(
|
|
input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_bark_battle_runtime_config_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn start_bark_battle_run(
|
|
&self,
|
|
input: BarkBattleRunStartRecordInput,
|
|
) -> Result<BarkBattleRunRecord, SpacetimeClientError> {
|
|
self.call_after_connect("start_bark_battle_run", move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.start_bark_battle_run_then(input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_bark_battle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn finish_bark_battle_run(
|
|
&self,
|
|
input: BarkBattleRunFinishRecordInput,
|
|
) -> Result<BarkBattleRunRecord, SpacetimeClientError> {
|
|
self.call_after_connect("finish_bark_battle_run", move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.finish_bark_battle_run_then(input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_bark_battle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn get_bark_battle_run(
|
|
&self,
|
|
run_id: String,
|
|
owner_user_id: String,
|
|
) -> Result<BarkBattleRunRecord, SpacetimeClientError> {
|
|
let input = BarkBattleRunGetInput {
|
|
run_id,
|
|
owner_user_id,
|
|
};
|
|
self.call_after_connect("get_bark_battle_run", move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.get_bark_battle_run_then(input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_bark_battle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn list_bark_battle_works(
|
|
&self,
|
|
owner_user_id: String,
|
|
) -> Result<Vec<serde_json::Value>, SpacetimeClientError> {
|
|
self.read_after_connect("list_bark_battle_works", move |connection| {
|
|
let owner_user_id = owner_user_id.as_str();
|
|
let drafts: Vec<serde_json::Value> = connection
|
|
.db()
|
|
.bark_battle_draft_config()
|
|
.iter()
|
|
.filter(|row| row.owner_user_id == owner_user_id)
|
|
.map(map_bark_battle_draft_config_row)
|
|
.collect();
|
|
let published: Vec<serde_json::Value> = connection
|
|
.db()
|
|
.bark_battle_published_config()
|
|
.iter()
|
|
.filter(|row| row.owner_user_id == owner_user_id)
|
|
.map(map_bark_battle_published_config_row)
|
|
.collect();
|
|
|
|
let mut works_by_id: HashMap<String, serde_json::Value> = HashMap::new();
|
|
for work in published.into_iter().chain(drafts) {
|
|
let Some(work_id) = work
|
|
.get("workId")
|
|
.and_then(serde_json::Value::as_str)
|
|
.filter(|value| !value.trim().is_empty())
|
|
.map(ToString::to_string)
|
|
else {
|
|
continue;
|
|
};
|
|
works_by_id.entry(work_id).or_insert(work);
|
|
}
|
|
|
|
let mut works: Vec<serde_json::Value> = works_by_id.into_values().collect();
|
|
works.sort_by(|left: &serde_json::Value, right: &serde_json::Value| {
|
|
let left_updated_at = left
|
|
.get("updatedAtMicros")
|
|
.and_then(serde_json::Value::as_i64)
|
|
.unwrap_or_default();
|
|
let right_updated_at = right
|
|
.get("updatedAtMicros")
|
|
.and_then(serde_json::Value::as_i64)
|
|
.unwrap_or_default();
|
|
right_updated_at.cmp(&left_updated_at)
|
|
});
|
|
Ok(works)
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn list_bark_battle_gallery(
|
|
&self,
|
|
) -> Result<Vec<serde_json::Value>, SpacetimeClientError> {
|
|
self.read_after_connect("list_bark_battle_gallery", move |connection| {
|
|
let recent_play_counts = public_work_recent_play_counts(connection, "bark-battle");
|
|
let mut items = connection
|
|
.db()
|
|
.bark_battle_gallery_view()
|
|
.iter()
|
|
.collect::<Vec<_>>();
|
|
items.sort_by(|left, right| {
|
|
right
|
|
.updated_at_micros
|
|
.cmp(&left.updated_at_micros)
|
|
.then_with(|| left.work_id.cmp(&right.work_id))
|
|
});
|
|
Ok(items
|
|
.into_iter()
|
|
.map(|item| {
|
|
let recent_play_count_7d =
|
|
recent_play_counts.get(&item.work_id).copied().unwrap_or(0);
|
|
map_bark_battle_gallery_view_row(item, recent_play_count_7d)
|
|
})
|
|
.collect())
|
|
})
|
|
.await
|
|
}
|
|
}
|