1327 lines
47 KiB
Rust
1327 lines
47 KiB
Rust
use super::*;
|
|
|
|
impl From<module_runtime::RuntimeProfileDashboardGetInput> for RuntimeProfileDashboardGetInput {
|
|
fn from(input: module_runtime::RuntimeProfileDashboardGetInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileWalletLedgerListInput>
|
|
for RuntimeProfileWalletLedgerListInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileWalletLedgerListInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileWalletAdjustmentInput>
|
|
for RuntimeProfileWalletAdjustmentInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileWalletAdjustmentInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
amount: input.amount,
|
|
ledger_id: input.ledger_id,
|
|
created_at_micros: input.created_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileRechargeCenterGetInput>
|
|
for RuntimeProfileRechargeCenterGetInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileRechargeCenterGetInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileRechargeOrderGetInput>
|
|
for RuntimeProfileRechargeOrderGetInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileRechargeOrderGetInput) -> Self {
|
|
Self {
|
|
order_id: input.order_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileRechargeOrderCreateInput>
|
|
for RuntimeProfileRechargeOrderCreateInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileRechargeOrderCreateInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
product_id: input.product_id,
|
|
payment_channel: input.payment_channel,
|
|
created_at_micros: input.created_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileRechargeOrderPaidInput>
|
|
for RuntimeProfileRechargeOrderPaidInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileRechargeOrderPaidInput) -> Self {
|
|
Self {
|
|
order_id: input.order_id,
|
|
paid_at_micros: input.paid_at_micros,
|
|
provider_transaction_id: input.provider_transaction_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileFeedbackSubmissionInput>
|
|
for RuntimeProfileFeedbackSubmissionInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileFeedbackSubmissionInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
description: input.description,
|
|
contact_phone: input.contact_phone,
|
|
evidence_items: input.evidence_items.into_iter().map(Into::into).collect(),
|
|
created_at_micros: input.created_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileFeedbackEvidenceSnapshot>
|
|
for RuntimeProfileFeedbackEvidenceSnapshot
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileFeedbackEvidenceSnapshot) -> Self {
|
|
Self {
|
|
evidence_id: input.evidence_id,
|
|
file_name: input.file_name,
|
|
content_type: input.content_type,
|
|
size_bytes: input.size_bytes,
|
|
data_url: input.data_url,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileRewardCodeRedeemInput>
|
|
for RuntimeProfileRewardCodeRedeemInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileRewardCodeRedeemInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
code: input.code,
|
|
redeemed_at_micros: input.redeemed_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileTaskCenterGetInput> for RuntimeProfileTaskCenterGetInput {
|
|
fn from(input: module_runtime::RuntimeProfileTaskCenterGetInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::AnalyticsMetricQueryInput> for AnalyticsMetricQueryInput {
|
|
fn from(input: module_runtime::AnalyticsMetricQueryInput) -> Self {
|
|
Self {
|
|
event_key: input.event_key,
|
|
scope_kind: map_runtime_tracking_scope_kind(input.scope_kind),
|
|
scope_id: input.scope_id,
|
|
granularity: map_analytics_granularity(input.granularity),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileTaskClaimInput> for RuntimeProfileTaskClaimInput {
|
|
fn from(input: module_runtime::RuntimeProfileTaskClaimInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
task_id: input.task_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileTaskConfigAdminListInput>
|
|
for RuntimeProfileTaskConfigAdminListInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileTaskConfigAdminListInput) -> Self {
|
|
Self {
|
|
admin_user_id: input.admin_user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileTaskConfigAdminUpsertInput>
|
|
for RuntimeProfileTaskConfigAdminUpsertInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileTaskConfigAdminUpsertInput) -> Self {
|
|
Self {
|
|
admin_user_id: input.admin_user_id,
|
|
task_id: input.task_id,
|
|
title: input.title,
|
|
description: input.description,
|
|
event_key: input.event_key,
|
|
cycle: map_runtime_profile_task_cycle(input.cycle),
|
|
scope_kind: map_runtime_tracking_scope_kind(input.scope_kind),
|
|
threshold: input.threshold,
|
|
reward_points: input.reward_points,
|
|
enabled: input.enabled,
|
|
sort_order: input.sort_order,
|
|
updated_at_micros: input.updated_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileTaskConfigAdminDisableInput>
|
|
for RuntimeProfileTaskConfigAdminDisableInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileTaskConfigAdminDisableInput) -> Self {
|
|
Self {
|
|
admin_user_id: input.admin_user_id,
|
|
task_id: input.task_id,
|
|
updated_at_micros: input.updated_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileRechargeProductAdminListInput>
|
|
for RuntimeProfileRechargeProductAdminListInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileRechargeProductAdminListInput) -> Self {
|
|
Self {
|
|
admin_user_id: input.admin_user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileRechargeProductAdminUpsertInput>
|
|
for RuntimeProfileRechargeProductAdminUpsertInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileRechargeProductAdminUpsertInput) -> Self {
|
|
Self {
|
|
admin_user_id: input.admin_user_id,
|
|
product_id: input.product_id,
|
|
title: input.title,
|
|
price_cents: input.price_cents,
|
|
kind: map_runtime_profile_recharge_product_kind(input.kind),
|
|
points_amount: input.points_amount,
|
|
bonus_points: input.bonus_points,
|
|
duration_days: input.duration_days,
|
|
badge_label: input.badge_label,
|
|
description: input.description,
|
|
tier: map_runtime_profile_membership_tier(input.tier),
|
|
enabled: input.enabled,
|
|
sort_order: input.sort_order,
|
|
updated_at_micros: input.updated_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileRedeemCodeAdminUpsertInput>
|
|
for RuntimeProfileRedeemCodeAdminUpsertInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileRedeemCodeAdminUpsertInput) -> Self {
|
|
Self {
|
|
admin_user_id: input.admin_user_id,
|
|
code: input.code,
|
|
mode: map_runtime_profile_redeem_code_mode(input.mode),
|
|
reward_points: input.reward_points,
|
|
max_uses: input.max_uses,
|
|
enabled: input.enabled,
|
|
allowed_user_ids: input.allowed_user_ids,
|
|
allowed_public_user_codes: input.allowed_public_user_codes,
|
|
updated_at_micros: input.updated_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileRedeemCodeAdminDisableInput>
|
|
for RuntimeProfileRedeemCodeAdminDisableInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileRedeemCodeAdminDisableInput) -> Self {
|
|
Self {
|
|
admin_user_id: input.admin_user_id,
|
|
code: input.code,
|
|
updated_at_micros: input.updated_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileRedeemCodeAdminListInput>
|
|
for RuntimeProfileRedeemCodeAdminListInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileRedeemCodeAdminListInput) -> Self {
|
|
Self {
|
|
admin_user_id: input.admin_user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileInviteCodeAdminUpsertInput>
|
|
for RuntimeProfileInviteCodeAdminUpsertInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileInviteCodeAdminUpsertInput) -> Self {
|
|
Self {
|
|
admin_user_id: input.admin_user_id,
|
|
invite_code: input.invite_code,
|
|
metadata_json: input.metadata_json,
|
|
starts_at_micros: input.starts_at_micros,
|
|
expires_at_micros: input.expires_at_micros,
|
|
updated_at_micros: input.updated_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileInviteCodeAdminListInput>
|
|
for RuntimeProfileInviteCodeAdminListInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileInviteCodeAdminListInput) -> Self {
|
|
Self {
|
|
admin_user_id: input.admin_user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeReferralInviteCenterGetInput>
|
|
for RuntimeReferralInviteCenterGetInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeReferralInviteCenterGetInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeReferralRedeemInput> for RuntimeReferralRedeemInput {
|
|
fn from(input: module_runtime::RuntimeReferralRedeemInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
invite_code: input.invite_code,
|
|
updated_at_micros: input.updated_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfilePlayStatsGetInput> for RuntimeProfilePlayStatsGetInput {
|
|
fn from(input: module_runtime::RuntimeProfilePlayStatsGetInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileSaveArchiveListInput>
|
|
for RuntimeProfileSaveArchiveListInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileSaveArchiveListInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<module_runtime::RuntimeProfileSaveArchiveResumeInput>
|
|
for RuntimeProfileSaveArchiveResumeInput
|
|
{
|
|
fn from(input: module_runtime::RuntimeProfileSaveArchiveResumeInput) -> Self {
|
|
Self {
|
|
user_id: input.user_id,
|
|
world_key: input.world_key,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_dashboard_procedure_result(
|
|
result: RuntimeProfileDashboardProcedureResult,
|
|
) -> Result<RuntimeProfileDashboardRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("profile dashboard 快照"))?;
|
|
|
|
Ok(build_runtime_profile_dashboard_record(
|
|
map_runtime_profile_dashboard_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_wallet_ledger_procedure_result(
|
|
result: RuntimeProfileWalletLedgerProcedureResult,
|
|
) -> Result<Vec<RuntimeProfileWalletLedgerEntryRecord>, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
Ok(result
|
|
.entries
|
|
.into_iter()
|
|
.map(|snapshot| {
|
|
build_runtime_profile_wallet_ledger_entry_record(
|
|
map_runtime_profile_wallet_ledger_entry_snapshot(snapshot),
|
|
)
|
|
})
|
|
.collect())
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_wallet_adjustment_procedure_result(
|
|
result: RuntimeProfileWalletAdjustmentProcedureResult,
|
|
) -> Result<RuntimeProfileDashboardRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("profile dashboard 快照"))?;
|
|
|
|
Ok(build_runtime_profile_dashboard_record(
|
|
map_runtime_profile_dashboard_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_center_procedure_result(
|
|
result: RuntimeProfileRechargeCenterProcedureResult,
|
|
) -> Result<RuntimeProfileRechargeCenterRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("profile recharge center 快照"))?;
|
|
|
|
Ok(build_runtime_profile_recharge_center_record(
|
|
map_runtime_profile_recharge_center_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_order_procedure_result(
|
|
result: RuntimeProfileRechargeCenterProcedureResult,
|
|
) -> Result<
|
|
(
|
|
RuntimeProfileRechargeCenterRecord,
|
|
RuntimeProfileRechargeOrderRecord,
|
|
),
|
|
SpacetimeClientError,
|
|
> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let center = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("profile recharge center 快照"))?;
|
|
let order = result
|
|
.order
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("profile recharge order 快照"))?;
|
|
|
|
Ok((
|
|
build_runtime_profile_recharge_center_record(map_runtime_profile_recharge_center_snapshot(
|
|
center,
|
|
)),
|
|
module_runtime::build_runtime_profile_recharge_order_record(
|
|
map_runtime_profile_recharge_order_snapshot(order),
|
|
),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_feedback_submission_procedure_result(
|
|
result: RuntimeProfileFeedbackSubmissionProcedureResult,
|
|
) -> Result<RuntimeProfileFeedbackSubmissionRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("profile feedback 快照"))?;
|
|
|
|
build_runtime_profile_feedback_submission_record(
|
|
map_runtime_profile_feedback_submission_snapshot(snapshot),
|
|
)
|
|
.map_err(SpacetimeClientError::validation_failed)
|
|
}
|
|
|
|
pub(crate) fn map_runtime_referral_invite_center_procedure_result(
|
|
result: RuntimeReferralInviteCenterProcedureResult,
|
|
) -> Result<RuntimeReferralInviteCenterRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("referral invite center 快照"))?;
|
|
|
|
Ok(build_runtime_referral_invite_center_record(
|
|
map_runtime_referral_invite_center_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_referral_redeem_procedure_result(
|
|
result: RuntimeReferralRedeemProcedureResult,
|
|
) -> Result<RuntimeReferralRedeemRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("referral redeem 快照"))?;
|
|
|
|
Ok(build_runtime_referral_redeem_record(
|
|
map_runtime_referral_redeem_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_reward_code_redeem_procedure_result(
|
|
result: RuntimeProfileRewardCodeRedeemProcedureResult,
|
|
) -> Result<RuntimeProfileRewardCodeRedeemRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("reward redeem 快照"))?;
|
|
|
|
Ok(build_runtime_profile_reward_code_redeem_record(
|
|
map_runtime_profile_reward_code_redeem_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_center_procedure_result(
|
|
result: RuntimeProfileTaskCenterProcedureResult,
|
|
) -> Result<RuntimeProfileTaskCenterRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("profile task center 快照"))?;
|
|
|
|
Ok(build_runtime_profile_task_center_record(
|
|
map_runtime_profile_task_center_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_analytics_metric_query_procedure_result(
|
|
result: AnalyticsMetricQueryProcedureResult,
|
|
) -> Result<DomainAnalyticsMetricQueryResponse, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
Ok(DomainAnalyticsMetricQueryResponse {
|
|
buckets: result
|
|
.buckets
|
|
.into_iter()
|
|
.map(map_analytics_bucket_metric)
|
|
.collect(),
|
|
})
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_claim_procedure_result(
|
|
result: RuntimeProfileTaskClaimProcedureResult,
|
|
) -> Result<RuntimeProfileTaskClaimRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("profile task claim 快照"))?;
|
|
|
|
Ok(build_runtime_profile_task_claim_record(
|
|
map_runtime_profile_task_claim_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_config_admin_list_procedure_result(
|
|
result: RuntimeProfileTaskConfigAdminListProcedureResult,
|
|
) -> Result<Vec<RuntimeProfileTaskConfigRecord>, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
Ok(result
|
|
.entries
|
|
.into_iter()
|
|
.map(|snapshot| {
|
|
build_runtime_profile_task_config_record(map_runtime_profile_task_config_snapshot(
|
|
snapshot,
|
|
))
|
|
})
|
|
.collect())
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_config_admin_procedure_result(
|
|
result: RuntimeProfileTaskConfigAdminProcedureResult,
|
|
) -> Result<RuntimeProfileTaskConfigRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("profile task config 快照"))?;
|
|
|
|
Ok(build_runtime_profile_task_config_record(
|
|
map_runtime_profile_task_config_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_product_admin_list_procedure_result(
|
|
result: RuntimeProfileRechargeProductAdminListProcedureResult,
|
|
) -> Result<Vec<RuntimeProfileRechargeProductConfigRecord>, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
Ok(result
|
|
.entries
|
|
.into_iter()
|
|
.map(|snapshot| {
|
|
build_runtime_profile_recharge_product_config_record(
|
|
map_runtime_profile_recharge_product_config_snapshot(snapshot),
|
|
)
|
|
})
|
|
.collect())
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_product_admin_procedure_result(
|
|
result: RuntimeProfileRechargeProductAdminProcedureResult,
|
|
) -> Result<RuntimeProfileRechargeProductConfigRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("recharge product config 快照"))?;
|
|
|
|
Ok(build_runtime_profile_recharge_product_config_record(
|
|
map_runtime_profile_recharge_product_config_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_redeem_code_admin_procedure_result(
|
|
result: RuntimeProfileRedeemCodeAdminProcedureResult,
|
|
) -> Result<RuntimeProfileRedeemCodeRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("redeem code 快照"))?;
|
|
|
|
Ok(build_runtime_profile_redeem_code_record(
|
|
map_runtime_profile_redeem_code_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_redeem_code_admin_list_procedure_result(
|
|
result: RuntimeProfileRedeemCodeAdminListProcedureResult,
|
|
) -> Result<Vec<RuntimeProfileRedeemCodeRecord>, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
Ok(result
|
|
.entries
|
|
.into_iter()
|
|
.map(|snapshot| {
|
|
build_runtime_profile_redeem_code_record(map_runtime_profile_redeem_code_snapshot(
|
|
snapshot,
|
|
))
|
|
})
|
|
.collect())
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_invite_code_admin_procedure_result(
|
|
result: RuntimeProfileInviteCodeAdminProcedureResult,
|
|
) -> Result<RuntimeProfileInviteCodeRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::Procedure(
|
|
result
|
|
.error_message
|
|
.unwrap_or_else(|| "SpacetimeDB procedure 返回未知错误".to_string()),
|
|
));
|
|
}
|
|
|
|
let snapshot = result.record.ok_or_else(|| {
|
|
SpacetimeClientError::Procedure("SpacetimeDB procedure 未返回 invite code 快照".to_string())
|
|
})?;
|
|
|
|
Ok(build_runtime_profile_invite_code_record(
|
|
map_runtime_profile_invite_code_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_invite_code_admin_list_procedure_result(
|
|
result: RuntimeProfileInviteCodeAdminListProcedureResult,
|
|
) -> Result<Vec<RuntimeProfileInviteCodeRecord>, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
Ok(result
|
|
.entries
|
|
.into_iter()
|
|
.map(|snapshot| {
|
|
build_runtime_profile_invite_code_record(map_runtime_profile_invite_code_snapshot(
|
|
snapshot,
|
|
))
|
|
})
|
|
.collect())
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_play_stats_procedure_result(
|
|
result: RuntimeProfilePlayStatsProcedureResult,
|
|
) -> Result<RuntimeProfilePlayStatsRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let snapshot = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("profile play stats 快照"))?;
|
|
|
|
Ok(build_runtime_profile_play_stats_record(
|
|
map_runtime_profile_play_stats_snapshot(snapshot),
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_save_archive_list_procedure_result(
|
|
result: RuntimeProfileSaveArchiveProcedureResult,
|
|
) -> Result<Vec<RuntimeProfileSaveArchiveRecord>, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
result
|
|
.entries
|
|
.into_iter()
|
|
.map(|snapshot| {
|
|
build_runtime_profile_save_archive_record(map_runtime_profile_save_archive_snapshot(
|
|
snapshot,
|
|
))
|
|
.map_err(|error| SpacetimeClientError::Runtime(error.to_string()))
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_save_archive_resume_procedure_result(
|
|
result: RuntimeProfileSaveArchiveProcedureResult,
|
|
) -> Result<(RuntimeProfileSaveArchiveRecord, RuntimeSnapshotRecord), SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
|
|
let archive = result
|
|
.record
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("save archive 快照"))?;
|
|
let snapshot = result
|
|
.current_snapshot
|
|
.ok_or_else(|| SpacetimeClientError::missing_snapshot("恢复后的 runtime snapshot"))?;
|
|
|
|
Ok((
|
|
build_runtime_profile_save_archive_record(map_runtime_profile_save_archive_snapshot(
|
|
archive,
|
|
))
|
|
.map_err(|error| SpacetimeClientError::Runtime(error.to_string()))?,
|
|
build_runtime_snapshot_record(map_runtime_snapshot_snapshot(snapshot))
|
|
.map_err(|error| SpacetimeClientError::Runtime(error.to_string()))?,
|
|
))
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_dashboard_snapshot(
|
|
snapshot: RuntimeProfileDashboardSnapshot,
|
|
) -> module_runtime::RuntimeProfileDashboardSnapshot {
|
|
module_runtime::RuntimeProfileDashboardSnapshot {
|
|
user_id: snapshot.user_id,
|
|
wallet_balance: snapshot.wallet_balance,
|
|
total_play_time_ms: snapshot.total_play_time_ms,
|
|
played_world_count: snapshot.played_world_count,
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_analytics_bucket_metric(
|
|
bucket: AnalyticsBucketMetric,
|
|
) -> module_runtime::AnalyticsBucketMetric {
|
|
module_runtime::AnalyticsBucketMetric {
|
|
bucket_key: bucket.bucket_key,
|
|
bucket_start_date_key: bucket.bucket_start_date_key,
|
|
bucket_end_date_key: bucket.bucket_end_date_key,
|
|
value: bucket.value,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_wallet_ledger_entry_snapshot(
|
|
snapshot: RuntimeProfileWalletLedgerEntrySnapshot,
|
|
) -> module_runtime::RuntimeProfileWalletLedgerEntrySnapshot {
|
|
module_runtime::RuntimeProfileWalletLedgerEntrySnapshot {
|
|
wallet_ledger_id: snapshot.wallet_ledger_id,
|
|
user_id: snapshot.user_id,
|
|
amount_delta: snapshot.amount_delta,
|
|
balance_after: snapshot.balance_after,
|
|
source_type: map_runtime_profile_wallet_ledger_source_type_back(snapshot.source_type),
|
|
created_at_micros: snapshot.created_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_center_snapshot(
|
|
snapshot: RuntimeProfileRechargeCenterSnapshot,
|
|
) -> module_runtime::RuntimeProfileRechargeCenterSnapshot {
|
|
module_runtime::RuntimeProfileRechargeCenterSnapshot {
|
|
user_id: snapshot.user_id,
|
|
wallet_balance: snapshot.wallet_balance,
|
|
membership: map_runtime_profile_membership_snapshot(snapshot.membership),
|
|
point_products: snapshot
|
|
.point_products
|
|
.into_iter()
|
|
.map(map_runtime_profile_recharge_product_snapshot)
|
|
.collect(),
|
|
membership_products: snapshot
|
|
.membership_products
|
|
.into_iter()
|
|
.map(map_runtime_profile_recharge_product_snapshot)
|
|
.collect(),
|
|
benefits: snapshot
|
|
.benefits
|
|
.into_iter()
|
|
.map(map_runtime_profile_membership_benefit_snapshot)
|
|
.collect(),
|
|
latest_order: snapshot
|
|
.latest_order
|
|
.map(map_runtime_profile_recharge_order_snapshot),
|
|
has_points_recharged: snapshot.has_points_recharged,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_product_snapshot(
|
|
snapshot: RuntimeProfileRechargeProductSnapshot,
|
|
) -> module_runtime::RuntimeProfileRechargeProductSnapshot {
|
|
module_runtime::RuntimeProfileRechargeProductSnapshot {
|
|
product_id: snapshot.product_id,
|
|
title: snapshot.title,
|
|
price_cents: snapshot.price_cents,
|
|
kind: map_runtime_profile_recharge_product_kind_back(snapshot.kind),
|
|
points_amount: snapshot.points_amount,
|
|
bonus_points: snapshot.bonus_points,
|
|
duration_days: snapshot.duration_days,
|
|
badge_label: snapshot.badge_label,
|
|
description: snapshot.description,
|
|
tier: map_runtime_profile_membership_tier_back(snapshot.tier),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_product_config_snapshot(
|
|
snapshot: RuntimeProfileRechargeProductConfigSnapshot,
|
|
) -> module_runtime::RuntimeProfileRechargeProductConfigSnapshot {
|
|
module_runtime::RuntimeProfileRechargeProductConfigSnapshot {
|
|
product_id: snapshot.product_id,
|
|
title: snapshot.title,
|
|
price_cents: snapshot.price_cents,
|
|
kind: map_runtime_profile_recharge_product_kind_back(snapshot.kind),
|
|
points_amount: snapshot.points_amount,
|
|
bonus_points: snapshot.bonus_points,
|
|
duration_days: snapshot.duration_days,
|
|
badge_label: snapshot.badge_label,
|
|
description: snapshot.description,
|
|
tier: map_runtime_profile_membership_tier_back(snapshot.tier),
|
|
enabled: snapshot.enabled,
|
|
sort_order: snapshot.sort_order,
|
|
created_by: snapshot.created_by,
|
|
created_at_micros: snapshot.created_at_micros,
|
|
updated_by: snapshot.updated_by,
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_membership_benefit_snapshot(
|
|
snapshot: RuntimeProfileMembershipBenefitSnapshot,
|
|
) -> module_runtime::RuntimeProfileMembershipBenefitSnapshot {
|
|
module_runtime::RuntimeProfileMembershipBenefitSnapshot {
|
|
benefit_name: snapshot.benefit_name,
|
|
normal_value: snapshot.normal_value,
|
|
month_value: snapshot.month_value,
|
|
season_value: snapshot.season_value,
|
|
year_value: snapshot.year_value,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_membership_snapshot(
|
|
snapshot: RuntimeProfileMembershipSnapshot,
|
|
) -> module_runtime::RuntimeProfileMembershipSnapshot {
|
|
module_runtime::RuntimeProfileMembershipSnapshot {
|
|
user_id: snapshot.user_id,
|
|
status: map_runtime_profile_membership_status_back(snapshot.status),
|
|
tier: map_runtime_profile_membership_tier_back(snapshot.tier),
|
|
started_at_micros: snapshot.started_at_micros,
|
|
expires_at_micros: snapshot.expires_at_micros,
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_order_snapshot(
|
|
snapshot: RuntimeProfileRechargeOrderSnapshot,
|
|
) -> module_runtime::RuntimeProfileRechargeOrderSnapshot {
|
|
module_runtime::RuntimeProfileRechargeOrderSnapshot {
|
|
order_id: snapshot.order_id,
|
|
user_id: snapshot.user_id,
|
|
product_id: snapshot.product_id,
|
|
product_title: snapshot.product_title,
|
|
kind: map_runtime_profile_recharge_product_kind_back(snapshot.kind),
|
|
amount_cents: snapshot.amount_cents,
|
|
status: map_runtime_profile_recharge_order_status_back(snapshot.status),
|
|
payment_channel: snapshot.payment_channel,
|
|
paid_at_micros: snapshot.paid_at_micros,
|
|
provider_transaction_id: snapshot.provider_transaction_id,
|
|
created_at_micros: snapshot.created_at_micros,
|
|
points_delta: snapshot.points_delta,
|
|
membership_expires_at_micros: snapshot.membership_expires_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_feedback_submission_snapshot(
|
|
snapshot: RuntimeProfileFeedbackSubmissionSnapshot,
|
|
) -> module_runtime::RuntimeProfileFeedbackSubmissionSnapshot {
|
|
module_runtime::RuntimeProfileFeedbackSubmissionSnapshot {
|
|
feedback_id: snapshot.feedback_id,
|
|
user_id: snapshot.user_id,
|
|
description: snapshot.description,
|
|
contact_phone: snapshot.contact_phone,
|
|
evidence_json: snapshot.evidence_json,
|
|
status: map_runtime_profile_feedback_status_back(snapshot.status),
|
|
created_at_micros: snapshot.created_at_micros,
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_referral_invite_center_snapshot(
|
|
snapshot: RuntimeReferralInviteCenterSnapshot,
|
|
) -> module_runtime::RuntimeReferralInviteCenterSnapshot {
|
|
module_runtime::RuntimeReferralInviteCenterSnapshot {
|
|
user_id: snapshot.user_id,
|
|
invite_code: snapshot.invite_code,
|
|
invite_link_path: snapshot.invite_link_path,
|
|
invited_count: snapshot.invited_count,
|
|
rewarded_invite_count: snapshot.rewarded_invite_count,
|
|
today_inviter_reward_count: snapshot.today_inviter_reward_count,
|
|
today_inviter_reward_remaining: snapshot.today_inviter_reward_remaining,
|
|
reward_points: snapshot.reward_points,
|
|
invited_users: snapshot
|
|
.invited_users
|
|
.into_iter()
|
|
.map(|user| module_runtime::RuntimeReferralInvitedUserSnapshot {
|
|
user_id: user.user_id,
|
|
display_name: user.display_name,
|
|
avatar_url: user.avatar_url,
|
|
bound_at_micros: user.bound_at_micros,
|
|
})
|
|
.collect(),
|
|
has_redeemed_code: snapshot.has_redeemed_code,
|
|
bound_inviter_user_id: snapshot.bound_inviter_user_id,
|
|
bound_at_micros: snapshot.bound_at_micros,
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_referral_redeem_snapshot(
|
|
snapshot: RuntimeReferralRedeemSnapshot,
|
|
) -> module_runtime::RuntimeReferralRedeemSnapshot {
|
|
module_runtime::RuntimeReferralRedeemSnapshot {
|
|
center: map_runtime_referral_invite_center_snapshot(snapshot.center),
|
|
invitee_reward_granted: snapshot.invitee_reward_granted,
|
|
inviter_reward_granted: snapshot.inviter_reward_granted,
|
|
invitee_balance_after: snapshot.invitee_balance_after,
|
|
inviter_balance_after: snapshot.inviter_balance_after,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_reward_code_redeem_snapshot(
|
|
snapshot: RuntimeProfileRewardCodeRedeemSnapshot,
|
|
) -> module_runtime::RuntimeProfileRewardCodeRedeemSnapshot {
|
|
module_runtime::RuntimeProfileRewardCodeRedeemSnapshot {
|
|
wallet_balance: snapshot.wallet_balance,
|
|
amount_granted: snapshot.amount_granted,
|
|
ledger_entry: map_runtime_profile_wallet_ledger_entry_snapshot(snapshot.ledger_entry),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_config_snapshot(
|
|
snapshot: RuntimeProfileTaskConfigSnapshot,
|
|
) -> module_runtime::RuntimeProfileTaskConfigSnapshot {
|
|
module_runtime::RuntimeProfileTaskConfigSnapshot {
|
|
task_id: snapshot.task_id,
|
|
title: snapshot.title,
|
|
description: snapshot.description,
|
|
event_key: snapshot.event_key,
|
|
cycle: map_runtime_profile_task_cycle_back(snapshot.cycle),
|
|
scope_kind: map_runtime_tracking_scope_kind_back(snapshot.scope_kind),
|
|
threshold: snapshot.threshold,
|
|
reward_points: snapshot.reward_points,
|
|
enabled: snapshot.enabled,
|
|
sort_order: snapshot.sort_order,
|
|
created_by: snapshot.created_by,
|
|
created_at_micros: snapshot.created_at_micros,
|
|
updated_by: snapshot.updated_by,
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_item_snapshot(
|
|
snapshot: RuntimeProfileTaskItemSnapshot,
|
|
) -> module_runtime::RuntimeProfileTaskItemSnapshot {
|
|
module_runtime::RuntimeProfileTaskItemSnapshot {
|
|
task_id: snapshot.task_id,
|
|
title: snapshot.title,
|
|
description: snapshot.description,
|
|
event_key: snapshot.event_key,
|
|
cycle: map_runtime_profile_task_cycle_back(snapshot.cycle),
|
|
threshold: snapshot.threshold,
|
|
progress_count: snapshot.progress_count,
|
|
reward_points: snapshot.reward_points,
|
|
status: map_runtime_profile_task_status_back(snapshot.status),
|
|
day_key: snapshot.day_key,
|
|
claimed_at_micros: snapshot.claimed_at_micros,
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_center_snapshot(
|
|
snapshot: RuntimeProfileTaskCenterSnapshot,
|
|
) -> module_runtime::RuntimeProfileTaskCenterSnapshot {
|
|
module_runtime::RuntimeProfileTaskCenterSnapshot {
|
|
user_id: snapshot.user_id,
|
|
day_key: snapshot.day_key,
|
|
wallet_balance: snapshot.wallet_balance,
|
|
tasks: snapshot
|
|
.tasks
|
|
.into_iter()
|
|
.map(map_runtime_profile_task_item_snapshot)
|
|
.collect(),
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_claim_snapshot(
|
|
snapshot: RuntimeProfileTaskClaimSnapshot,
|
|
) -> module_runtime::RuntimeProfileTaskClaimSnapshot {
|
|
module_runtime::RuntimeProfileTaskClaimSnapshot {
|
|
user_id: snapshot.user_id,
|
|
task_id: snapshot.task_id,
|
|
day_key: snapshot.day_key,
|
|
reward_points: snapshot.reward_points,
|
|
wallet_balance: snapshot.wallet_balance,
|
|
ledger_entry: map_runtime_profile_wallet_ledger_entry_snapshot(snapshot.ledger_entry),
|
|
center: map_runtime_profile_task_center_snapshot(snapshot.center),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_redeem_code_snapshot(
|
|
snapshot: RuntimeProfileRedeemCodeSnapshot,
|
|
) -> module_runtime::RuntimeProfileRedeemCodeSnapshot {
|
|
module_runtime::RuntimeProfileRedeemCodeSnapshot {
|
|
code: snapshot.code,
|
|
mode: map_runtime_profile_redeem_code_mode_back(snapshot.mode),
|
|
reward_points: snapshot.reward_points,
|
|
max_uses: snapshot.max_uses,
|
|
global_used_count: snapshot.global_used_count,
|
|
enabled: snapshot.enabled,
|
|
allowed_user_ids: snapshot.allowed_user_ids,
|
|
created_by: snapshot.created_by,
|
|
created_at_micros: snapshot.created_at_micros,
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_invite_code_snapshot(
|
|
snapshot: RuntimeProfileInviteCodeSnapshot,
|
|
) -> module_runtime::RuntimeProfileInviteCodeSnapshot {
|
|
module_runtime::RuntimeProfileInviteCodeSnapshot {
|
|
user_id: snapshot.user_id,
|
|
invite_code: snapshot.invite_code,
|
|
metadata_json: snapshot.metadata_json,
|
|
starts_at_micros: snapshot.starts_at_micros,
|
|
expires_at_micros: snapshot.expires_at_micros,
|
|
created_at_micros: snapshot.created_at_micros,
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_played_world_snapshot(
|
|
snapshot: RuntimeProfilePlayedWorldSnapshot,
|
|
) -> module_runtime::RuntimeProfilePlayedWorldSnapshot {
|
|
module_runtime::RuntimeProfilePlayedWorldSnapshot {
|
|
played_world_id: snapshot.played_world_id,
|
|
user_id: snapshot.user_id,
|
|
world_key: snapshot.world_key,
|
|
owner_user_id: snapshot.owner_user_id,
|
|
profile_id: snapshot.profile_id,
|
|
world_type: snapshot.world_type,
|
|
world_title: snapshot.world_title,
|
|
world_subtitle: snapshot.world_subtitle,
|
|
first_played_at_micros: snapshot.first_played_at_micros,
|
|
last_played_at_micros: snapshot.last_played_at_micros,
|
|
last_observed_play_time_ms: snapshot.last_observed_play_time_ms,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_play_stats_snapshot(
|
|
snapshot: RuntimeProfilePlayStatsSnapshot,
|
|
) -> module_runtime::RuntimeProfilePlayStatsSnapshot {
|
|
module_runtime::RuntimeProfilePlayStatsSnapshot {
|
|
user_id: snapshot.user_id,
|
|
total_play_time_ms: snapshot.total_play_time_ms,
|
|
played_works: snapshot
|
|
.played_works
|
|
.into_iter()
|
|
.map(map_runtime_profile_played_world_snapshot)
|
|
.collect(),
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_analytics_granularity(
|
|
granularity: module_runtime::AnalyticsGranularity,
|
|
) -> AnalyticsGranularity {
|
|
match granularity {
|
|
module_runtime::AnalyticsGranularity::Day => AnalyticsGranularity::Day,
|
|
module_runtime::AnalyticsGranularity::Week => AnalyticsGranularity::Week,
|
|
module_runtime::AnalyticsGranularity::Month => AnalyticsGranularity::Month,
|
|
module_runtime::AnalyticsGranularity::Quarter => AnalyticsGranularity::Quarter,
|
|
module_runtime::AnalyticsGranularity::Year => AnalyticsGranularity::Year,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_cycle(
|
|
value: DomainRuntimeProfileTaskCycle,
|
|
) -> crate::module_bindings::RuntimeProfileTaskCycle {
|
|
match value {
|
|
DomainRuntimeProfileTaskCycle::Daily => {
|
|
crate::module_bindings::RuntimeProfileTaskCycle::Daily
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_cycle_back(
|
|
value: crate::module_bindings::RuntimeProfileTaskCycle,
|
|
) -> DomainRuntimeProfileTaskCycle {
|
|
match value {
|
|
crate::module_bindings::RuntimeProfileTaskCycle::Daily => {
|
|
DomainRuntimeProfileTaskCycle::Daily
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_task_status_back(
|
|
value: crate::module_bindings::RuntimeProfileTaskStatus,
|
|
) -> DomainRuntimeProfileTaskStatus {
|
|
match value {
|
|
crate::module_bindings::RuntimeProfileTaskStatus::Incomplete => {
|
|
DomainRuntimeProfileTaskStatus::Incomplete
|
|
}
|
|
crate::module_bindings::RuntimeProfileTaskStatus::Claimable => {
|
|
DomainRuntimeProfileTaskStatus::Claimable
|
|
}
|
|
crate::module_bindings::RuntimeProfileTaskStatus::Claimed => {
|
|
DomainRuntimeProfileTaskStatus::Claimed
|
|
}
|
|
crate::module_bindings::RuntimeProfileTaskStatus::Disabled => {
|
|
DomainRuntimeProfileTaskStatus::Disabled
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_redeem_code_mode(
|
|
value: module_runtime::RuntimeProfileRedeemCodeMode,
|
|
) -> crate::module_bindings::RuntimeProfileRedeemCodeMode {
|
|
match value {
|
|
module_runtime::RuntimeProfileRedeemCodeMode::Public => {
|
|
crate::module_bindings::RuntimeProfileRedeemCodeMode::Public
|
|
}
|
|
module_runtime::RuntimeProfileRedeemCodeMode::Unique => {
|
|
crate::module_bindings::RuntimeProfileRedeemCodeMode::Unique
|
|
}
|
|
module_runtime::RuntimeProfileRedeemCodeMode::Private => {
|
|
crate::module_bindings::RuntimeProfileRedeemCodeMode::Private
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_redeem_code_mode_back(
|
|
value: crate::module_bindings::RuntimeProfileRedeemCodeMode,
|
|
) -> module_runtime::RuntimeProfileRedeemCodeMode {
|
|
match value {
|
|
crate::module_bindings::RuntimeProfileRedeemCodeMode::Public => {
|
|
module_runtime::RuntimeProfileRedeemCodeMode::Public
|
|
}
|
|
crate::module_bindings::RuntimeProfileRedeemCodeMode::Unique => {
|
|
module_runtime::RuntimeProfileRedeemCodeMode::Unique
|
|
}
|
|
crate::module_bindings::RuntimeProfileRedeemCodeMode::Private => {
|
|
module_runtime::RuntimeProfileRedeemCodeMode::Private
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_product_kind(
|
|
value: module_runtime::RuntimeProfileRechargeProductKind,
|
|
) -> crate::module_bindings::RuntimeProfileRechargeProductKind {
|
|
match value {
|
|
module_runtime::RuntimeProfileRechargeProductKind::Points => {
|
|
crate::module_bindings::RuntimeProfileRechargeProductKind::Points
|
|
}
|
|
module_runtime::RuntimeProfileRechargeProductKind::Membership => {
|
|
crate::module_bindings::RuntimeProfileRechargeProductKind::Membership
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_product_kind_back(
|
|
value: crate::module_bindings::RuntimeProfileRechargeProductKind,
|
|
) -> module_runtime::RuntimeProfileRechargeProductKind {
|
|
match value {
|
|
crate::module_bindings::RuntimeProfileRechargeProductKind::Points => {
|
|
module_runtime::RuntimeProfileRechargeProductKind::Points
|
|
}
|
|
crate::module_bindings::RuntimeProfileRechargeProductKind::Membership => {
|
|
module_runtime::RuntimeProfileRechargeProductKind::Membership
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_membership_tier(
|
|
value: module_runtime::RuntimeProfileMembershipTier,
|
|
) -> crate::module_bindings::RuntimeProfileMembershipTier {
|
|
match value {
|
|
module_runtime::RuntimeProfileMembershipTier::Normal => {
|
|
crate::module_bindings::RuntimeProfileMembershipTier::Normal
|
|
}
|
|
module_runtime::RuntimeProfileMembershipTier::Month => {
|
|
crate::module_bindings::RuntimeProfileMembershipTier::Month
|
|
}
|
|
module_runtime::RuntimeProfileMembershipTier::Season => {
|
|
crate::module_bindings::RuntimeProfileMembershipTier::Season
|
|
}
|
|
module_runtime::RuntimeProfileMembershipTier::Year => {
|
|
crate::module_bindings::RuntimeProfileMembershipTier::Year
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_membership_status_back(
|
|
value: crate::module_bindings::RuntimeProfileMembershipStatus,
|
|
) -> module_runtime::RuntimeProfileMembershipStatus {
|
|
match value {
|
|
crate::module_bindings::RuntimeProfileMembershipStatus::Normal => {
|
|
module_runtime::RuntimeProfileMembershipStatus::Normal
|
|
}
|
|
crate::module_bindings::RuntimeProfileMembershipStatus::Active => {
|
|
module_runtime::RuntimeProfileMembershipStatus::Active
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_membership_tier_back(
|
|
value: crate::module_bindings::RuntimeProfileMembershipTier,
|
|
) -> module_runtime::RuntimeProfileMembershipTier {
|
|
match value {
|
|
crate::module_bindings::RuntimeProfileMembershipTier::Normal => {
|
|
module_runtime::RuntimeProfileMembershipTier::Normal
|
|
}
|
|
crate::module_bindings::RuntimeProfileMembershipTier::Month => {
|
|
module_runtime::RuntimeProfileMembershipTier::Month
|
|
}
|
|
crate::module_bindings::RuntimeProfileMembershipTier::Season => {
|
|
module_runtime::RuntimeProfileMembershipTier::Season
|
|
}
|
|
crate::module_bindings::RuntimeProfileMembershipTier::Year => {
|
|
module_runtime::RuntimeProfileMembershipTier::Year
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_recharge_order_status_back(
|
|
value: crate::module_bindings::RuntimeProfileRechargeOrderStatus,
|
|
) -> module_runtime::RuntimeProfileRechargeOrderStatus {
|
|
match value {
|
|
crate::module_bindings::RuntimeProfileRechargeOrderStatus::Pending => {
|
|
module_runtime::RuntimeProfileRechargeOrderStatus::Pending
|
|
}
|
|
crate::module_bindings::RuntimeProfileRechargeOrderStatus::Paid => {
|
|
module_runtime::RuntimeProfileRechargeOrderStatus::Paid
|
|
}
|
|
crate::module_bindings::RuntimeProfileRechargeOrderStatus::Failed => {
|
|
module_runtime::RuntimeProfileRechargeOrderStatus::Failed
|
|
}
|
|
crate::module_bindings::RuntimeProfileRechargeOrderStatus::Closed => {
|
|
module_runtime::RuntimeProfileRechargeOrderStatus::Closed
|
|
}
|
|
crate::module_bindings::RuntimeProfileRechargeOrderStatus::Refunded => {
|
|
module_runtime::RuntimeProfileRechargeOrderStatus::Refunded
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn map_runtime_profile_feedback_status_back(
|
|
value: crate::module_bindings::RuntimeProfileFeedbackStatus,
|
|
) -> module_runtime::RuntimeProfileFeedbackStatus {
|
|
match value {
|
|
crate::module_bindings::RuntimeProfileFeedbackStatus::Open => {
|
|
module_runtime::RuntimeProfileFeedbackStatus::Open
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct SquareHoleDropFeedbackRecord {
|
|
pub accepted: bool,
|
|
pub reject_reason: Option<String>,
|
|
pub message: String,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct SquareHoleRunRecord {
|
|
pub run_id: String,
|
|
pub profile_id: String,
|
|
pub owner_user_id: String,
|
|
pub status: String,
|
|
pub snapshot_version: u64,
|
|
pub started_at_ms: u64,
|
|
pub duration_limit_ms: u64,
|
|
pub server_now_ms: Option<u64>,
|
|
pub remaining_ms: u64,
|
|
pub total_shape_count: u32,
|
|
pub completed_shape_count: u32,
|
|
pub combo: u32,
|
|
pub best_combo: u32,
|
|
pub score: u32,
|
|
pub rule_label: String,
|
|
pub background_image_src: Option<String>,
|
|
pub current_shape: Option<SquareHoleShapeSnapshotRecord>,
|
|
pub holes: Vec<SquareHoleHoleSnapshotRecord>,
|
|
pub last_feedback: Option<SquareHoleDropFeedbackRecord>,
|
|
pub last_confirmed_action_id: Option<String>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct SquareHoleDropConfirmationRecord {
|
|
pub status: String,
|
|
pub accepted: bool,
|
|
pub reject_reason: Option<String>,
|
|
pub failure_reason: Option<String>,
|
|
pub feedback: SquareHoleDropFeedbackRecord,
|
|
pub run: SquareHoleRunRecord,
|
|
}
|