658 lines
24 KiB
Rust
658 lines
24 KiB
Rust
use super::*;
|
|
use crate::mapper::*;
|
|
use crate::module_bindings::claim_puzzle_work_point_incentive_procedure::claim_puzzle_work_point_incentive;
|
|
use crate::module_bindings::delete_puzzle_work_procedure::delete_puzzle_work;
|
|
use crate::module_bindings::record_puzzle_work_like_procedure::record_puzzle_work_like;
|
|
use crate::module_bindings::remix_puzzle_work_procedure::remix_puzzle_work;
|
|
|
|
impl SpacetimeClient {
|
|
pub async fn create_puzzle_agent_session(
|
|
&self,
|
|
input: PuzzleAgentSessionCreateRecordInput,
|
|
) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleAgentSessionCreateInput {
|
|
session_id: input.session_id,
|
|
owner_user_id: input.owner_user_id,
|
|
seed_text: input.seed_text,
|
|
welcome_message_id: input.welcome_message_id,
|
|
welcome_message_text: input.welcome_message_text,
|
|
created_at_micros: input.created_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().create_puzzle_agent_session_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_agent_session_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn get_puzzle_agent_session(
|
|
&self,
|
|
session_id: String,
|
|
owner_user_id: String,
|
|
) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleAgentSessionGetInput {
|
|
session_id,
|
|
owner_user_id,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().get_puzzle_agent_session_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_agent_session_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn save_puzzle_form_draft(
|
|
&self,
|
|
input: PuzzleFormDraftSaveRecordInput,
|
|
) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleFormDraftSaveInput {
|
|
session_id: input.session_id,
|
|
owner_user_id: input.owner_user_id,
|
|
seed_text: input.seed_text,
|
|
saved_at_micros: input.saved_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().save_puzzle_form_draft_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_puzzle_agent_session_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn submit_puzzle_agent_message(
|
|
&self,
|
|
input: PuzzleAgentMessageSubmitRecordInput,
|
|
) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleAgentMessageSubmitInput {
|
|
session_id: input.session_id,
|
|
owner_user_id: input.owner_user_id,
|
|
user_message_id: input.user_message_id,
|
|
user_message_text: input.user_message_text,
|
|
submitted_at_micros: input.submitted_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().submit_puzzle_agent_message_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_agent_session_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn finalize_puzzle_agent_message(
|
|
&self,
|
|
input: PuzzleAgentMessageFinalizeRecordInput,
|
|
) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleAgentMessageFinalizeInput {
|
|
session_id: input.session_id,
|
|
owner_user_id: input.owner_user_id,
|
|
assistant_message_id: input.assistant_message_id,
|
|
assistant_reply_text: input.assistant_reply_text,
|
|
stage: parse_puzzle_agent_stage_record(input.stage.as_str())?,
|
|
progress_percent: input.progress_percent,
|
|
anchor_pack_json: input.anchor_pack_json,
|
|
error_message: input.error_message,
|
|
updated_at_micros: input.updated_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.finalize_puzzle_agent_message_turn_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_agent_session_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn compile_puzzle_agent_draft(
|
|
&self,
|
|
session_id: String,
|
|
owner_user_id: String,
|
|
compiled_at_micros: i64,
|
|
) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleDraftCompileInput {
|
|
session_id,
|
|
owner_user_id,
|
|
compiled_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().compile_puzzle_agent_draft_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_agent_session_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn save_puzzle_generated_images(
|
|
&self,
|
|
input: PuzzleGeneratedImagesSaveRecordInput,
|
|
) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleGeneratedImagesSaveInput {
|
|
session_id: input.session_id,
|
|
owner_user_id: input.owner_user_id,
|
|
level_id: input.level_id,
|
|
levels_json: input.levels_json,
|
|
candidates_json: input.candidates_json,
|
|
saved_at_micros: input.saved_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().save_puzzle_generated_images_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_agent_session_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn select_puzzle_cover_image(
|
|
&self,
|
|
input: PuzzleSelectCoverImageRecordInput,
|
|
) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleSelectCoverImageInput {
|
|
session_id: input.session_id,
|
|
owner_user_id: input.owner_user_id,
|
|
level_id: input.level_id,
|
|
candidate_id: input.candidate_id,
|
|
selected_at_micros: input.selected_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().select_puzzle_cover_image_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_agent_session_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn publish_puzzle_work(
|
|
&self,
|
|
input: PuzzlePublishRecordInput,
|
|
) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzlePublishInput {
|
|
session_id: input.session_id,
|
|
owner_user_id: input.owner_user_id,
|
|
work_id: input.work_id,
|
|
profile_id: input.profile_id,
|
|
author_display_name: input.author_display_name,
|
|
work_title: input.work_title,
|
|
work_description: input.work_description,
|
|
level_name: input.level_name,
|
|
summary: input.summary,
|
|
theme_tags: input.theme_tags,
|
|
levels_json: input.levels_json,
|
|
published_at_micros: input.published_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.publish_puzzle_work_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_work_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn list_puzzle_works(
|
|
&self,
|
|
owner_user_id: String,
|
|
) -> Result<Vec<PuzzleWorkProfileRecord>, SpacetimeClientError> {
|
|
let procedure_input = PuzzleWorksListInput { owner_user_id };
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.list_puzzle_works_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_works_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn get_puzzle_work_detail(
|
|
&self,
|
|
profile_id: String,
|
|
) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleWorkGetInput { profile_id };
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().get_puzzle_work_detail_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_work_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn update_puzzle_work(
|
|
&self,
|
|
input: PuzzleWorkUpsertRecordInput,
|
|
) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleWorkUpsertInput {
|
|
profile_id: input.profile_id,
|
|
owner_user_id: input.owner_user_id,
|
|
work_title: input.work_title,
|
|
work_description: input.work_description,
|
|
level_name: input.level_name,
|
|
summary: input.summary,
|
|
theme_tags: input.theme_tags,
|
|
cover_image_src: input.cover_image_src,
|
|
cover_asset_id: input.cover_asset_id,
|
|
levels_json: input.levels_json,
|
|
updated_at_micros: input.updated_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.update_puzzle_work_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_work_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn delete_puzzle_work(
|
|
&self,
|
|
profile_id: String,
|
|
owner_user_id: String,
|
|
) -> Result<Vec<PuzzleWorkProfileRecord>, SpacetimeClientError> {
|
|
let procedure_input = PuzzleWorkDeleteInput {
|
|
profile_id,
|
|
owner_user_id,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.delete_puzzle_work_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_works_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn claim_puzzle_work_point_incentive(
|
|
&self,
|
|
input: PuzzleWorkPointIncentiveClaimRecordInput,
|
|
) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleWorkPointIncentiveClaimInput {
|
|
profile_id: input.profile_id,
|
|
owner_user_id: input.owner_user_id,
|
|
claimed_at_micros: input.claimed_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.claim_puzzle_work_point_incentive_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_puzzle_work_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn list_puzzle_gallery(
|
|
&self,
|
|
) -> Result<Vec<PuzzleWorkProfileRecord>, SpacetimeClientError> {
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.list_puzzle_gallery_then(move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_works_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn get_puzzle_gallery_detail(
|
|
&self,
|
|
profile_id: String,
|
|
) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleWorkGetInput { profile_id };
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().get_puzzle_gallery_detail_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_work_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn record_puzzle_work_like(
|
|
&self,
|
|
input: PuzzleWorkLikeReportRecordInput,
|
|
) -> Result<PuzzleWorkProfileRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleWorkLikeRecordInput {
|
|
profile_id: input.profile_id,
|
|
user_id: input.user_id,
|
|
liked_at_micros: input.liked_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().record_puzzle_work_like_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_puzzle_work_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn remix_puzzle_work(
|
|
&self,
|
|
input: PuzzleWorkRemixRecordInput,
|
|
) -> Result<PuzzleAgentSessionRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleWorkRemixInput {
|
|
source_profile_id: input.source_profile_id,
|
|
target_owner_user_id: input.target_owner_user_id,
|
|
target_session_id: input.target_session_id,
|
|
target_profile_id: input.target_profile_id,
|
|
target_work_id: input.target_work_id,
|
|
author_display_name: input.author_display_name,
|
|
welcome_message_id: input.welcome_message_id,
|
|
remixed_at_micros: input.remixed_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.remix_puzzle_work_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_puzzle_agent_session_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn start_puzzle_run(
|
|
&self,
|
|
input: PuzzleRunStartRecordInput,
|
|
) -> Result<PuzzleRunRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleRunStartInput {
|
|
run_id: input.run_id,
|
|
owner_user_id: input.owner_user_id,
|
|
profile_id: input.profile_id,
|
|
level_id: input.level_id,
|
|
started_at_micros: input.started_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.start_puzzle_run_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn get_puzzle_run(
|
|
&self,
|
|
run_id: String,
|
|
owner_user_id: String,
|
|
) -> Result<PuzzleRunRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleRunGetInput {
|
|
run_id,
|
|
owner_user_id,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.get_puzzle_run_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn swap_puzzle_pieces(
|
|
&self,
|
|
input: PuzzleRunSwapRecordInput,
|
|
) -> Result<PuzzleRunRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleRunSwapInput {
|
|
run_id: input.run_id,
|
|
owner_user_id: input.owner_user_id,
|
|
first_piece_id: input.first_piece_id,
|
|
second_piece_id: input.second_piece_id,
|
|
swapped_at_micros: input.swapped_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.swap_puzzle_pieces_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn drag_puzzle_piece_or_group(
|
|
&self,
|
|
input: PuzzleRunDragRecordInput,
|
|
) -> Result<PuzzleRunRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleRunDragInput {
|
|
run_id: input.run_id,
|
|
owner_user_id: input.owner_user_id,
|
|
piece_id: input.piece_id,
|
|
target_row: input.target_row,
|
|
target_col: input.target_col,
|
|
dragged_at_micros: input.dragged_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().drag_puzzle_piece_or_group_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn advance_puzzle_next_level(
|
|
&self,
|
|
input: PuzzleRunNextLevelRecordInput,
|
|
) -> Result<PuzzleRunRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleRunNextLevelInput {
|
|
run_id: input.run_id,
|
|
owner_user_id: input.owner_user_id,
|
|
target_profile_id: input.target_profile_id,
|
|
advanced_at_micros: input.advanced_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().advance_puzzle_next_level_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn update_puzzle_run_pause(
|
|
&self,
|
|
input: PuzzleRunPauseRecordInput,
|
|
) -> Result<PuzzleRunRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleRunPauseInput {
|
|
run_id: input.run_id,
|
|
owner_user_id: input.owner_user_id,
|
|
paused: input.paused,
|
|
updated_at_micros: input.updated_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().update_puzzle_run_pause_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_puzzle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn use_puzzle_runtime_prop(
|
|
&self,
|
|
input: PuzzleRunPropRecordInput,
|
|
) -> Result<PuzzleRunRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleRunPropInput {
|
|
run_id: input.run_id,
|
|
owner_user_id: input.owner_user_id,
|
|
prop_kind: input.prop_kind,
|
|
used_at_micros: input.used_at_micros,
|
|
spent_points: input.spent_points,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection.procedures().use_puzzle_runtime_prop_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
|
|
.and_then(map_puzzle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
})
|
|
.await
|
|
}
|
|
|
|
pub async fn submit_puzzle_leaderboard_entry(
|
|
&self,
|
|
input: PuzzleLeaderboardSubmitRecordInput,
|
|
) -> Result<PuzzleRunRecord, SpacetimeClientError> {
|
|
let procedure_input = PuzzleLeaderboardSubmitInput {
|
|
run_id: input.run_id,
|
|
owner_user_id: input.owner_user_id,
|
|
profile_id: input.profile_id,
|
|
grid_size: input.grid_size,
|
|
elapsed_ms: input.elapsed_ms,
|
|
nickname: input.nickname,
|
|
submitted_at_micros: input.submitted_at_micros,
|
|
};
|
|
|
|
self.call_after_connect(move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.submit_puzzle_leaderboard_entry_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_puzzle_run_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
})
|
|
.await
|
|
}
|
|
}
|