kdletters
088470a315
将 api-server 微信 HTTP/BFF 适配统一迁移到 wechat 目录。 将微信支付和虚拟支付消息协议细节下沉到 platform-wechat。 拆分 platform-wechat 的订阅消息与支付模块并补齐依赖。 修正微信相关测试的用户 ID 夹具并同步后端架构文档。
3120 lines
116 KiB
Rust
3120 lines
116 KiB
Rust
use axum::{
|
|
Json,
|
|
extract::{Extension, Path, Query, State},
|
|
http::{HeaderMap, StatusCode},
|
|
response::{
|
|
IntoResponse, Response,
|
|
sse::{Event, Sse},
|
|
},
|
|
};
|
|
use hmac::{Hmac, Mac};
|
|
use module_runtime::{
|
|
AnalyticsGranularity, PROFILE_RECHARGE_PAYMENT_CHANNEL_MOCK,
|
|
PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_H5,
|
|
PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM,
|
|
PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM_VIRTUAL,
|
|
PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_NATIVE, RuntimeProfileFeedbackEvidenceRecord,
|
|
RuntimeProfileFeedbackEvidenceSnapshot, RuntimeProfileFeedbackSubmissionRecord,
|
|
RuntimeProfileInviteCodeRecord, RuntimeProfileMembershipBenefitRecord,
|
|
RuntimeProfileMembershipTier, RuntimeProfileRechargeCenterRecord,
|
|
RuntimeProfileRechargeOrderRecord, RuntimeProfileRechargeOrderStatus,
|
|
RuntimeProfileRechargeProductConfigRecord, RuntimeProfileRechargeProductKind,
|
|
RuntimeProfileRechargeProductRecord, RuntimeProfileRedeemCodeMode,
|
|
RuntimeProfileRedeemCodeRecord, RuntimeProfileRewardCodeRedeemRecord,
|
|
RuntimeProfileTaskCenterRecord, RuntimeProfileTaskClaimRecord, RuntimeProfileTaskConfigRecord,
|
|
RuntimeProfileTaskCycle, RuntimeProfileTaskItemRecord, RuntimeProfileTaskStatus,
|
|
RuntimeProfileWalletLedgerSourceType, RuntimeReferralInviteCenterRecord,
|
|
RuntimeTrackingScopeKind,
|
|
};
|
|
use platform_wechat::pay::WechatPayNotifyOrder;
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::{Value, json};
|
|
use sha2::Sha256;
|
|
use shared_contracts::runtime::{
|
|
ANALYTICS_GRANULARITY_DAY, ANALYTICS_GRANULARITY_MONTH, ANALYTICS_GRANULARITY_QUARTER,
|
|
ANALYTICS_GRANULARITY_WEEK, ANALYTICS_GRANULARITY_YEAR, AdminDisableProfileRedeemCodeRequest,
|
|
AdminDisableProfileTaskConfigRequest, AdminUpsertProfileInviteCodeRequest,
|
|
AdminUpsertProfileRechargeProductRequest, AdminUpsertProfileRedeemCodeRequest,
|
|
AdminUpsertProfileTaskConfigRequest, AnalyticsBucketMetricResponse,
|
|
AnalyticsMetricQueryResponse, ClaimProfileTaskRewardResponse,
|
|
ConfirmWechatProfileRechargeOrderResponse, CreateProfileRechargeOrderRequest,
|
|
CreateProfileRechargeOrderResponse, PROFILE_FEEDBACK_STATUS_OPEN,
|
|
PROFILE_MEMBERSHIP_TIER_MONTH, PROFILE_MEMBERSHIP_TIER_NORMAL, PROFILE_MEMBERSHIP_TIER_SEASON,
|
|
PROFILE_MEMBERSHIP_TIER_YEAR, PROFILE_RECHARGE_PRODUCT_KIND_MEMBERSHIP,
|
|
PROFILE_RECHARGE_PRODUCT_KIND_POINTS, PROFILE_TASK_CYCLE_DAILY, PROFILE_TASK_STATUS_CLAIMABLE,
|
|
PROFILE_TASK_STATUS_CLAIMED, PROFILE_TASK_STATUS_DISABLED, PROFILE_TASK_STATUS_INCOMPLETE,
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_ASSET_OPERATION_CONSUME,
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_ASSET_OPERATION_REFUND,
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_DAILY_TASK_REWARD,
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_INVITE_INVITEE_REWARD,
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_INVITE_INVITER_REWARD,
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_NEW_USER_REGISTRATION_REWARD,
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_POINTS_RECHARGE,
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_PUZZLE_AUTHOR_INCENTIVE_CLAIM,
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_REDEEM_CODE_REWARD,
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_SNAPSHOT_SYNC, ProfileDashboardSummaryResponse,
|
|
ProfileFeedbackEvidenceItemResponse, ProfileFeedbackSubmissionResponse,
|
|
ProfileInviteCodeAdminListResponse, ProfileInviteCodeAdminResponse,
|
|
ProfileMembershipBenefitResponse, ProfileMembershipResponse, ProfilePlayStatsResponse,
|
|
ProfilePlayedWorkSummaryResponse, ProfileRechargeCenterResponse, ProfileRechargeOrderResponse,
|
|
ProfileRechargeProductConfigAdminListResponse, ProfileRechargeProductConfigAdminResponse,
|
|
ProfileRechargeProductResponse, ProfileRedeemCodeAdminListResponse,
|
|
ProfileRedeemCodeAdminResponse, ProfileReferralInviteCenterResponse,
|
|
ProfileReferralInvitedUserResponse, ProfileTaskCenterResponse,
|
|
ProfileTaskConfigAdminListResponse, ProfileTaskConfigAdminResponse, ProfileTaskItemResponse,
|
|
ProfileWalletLedgerEntryResponse, ProfileWalletLedgerResponse,
|
|
RedeemProfileReferralInviteCodeRequest, RedeemProfileReferralInviteCodeResponse,
|
|
RedeemProfileRewardCodeRequest, RedeemProfileRewardCodeResponse, SubmitProfileFeedbackRequest,
|
|
SubmitProfileFeedbackResponse, TRACKING_SCOPE_KIND_MODULE, TRACKING_SCOPE_KIND_SITE,
|
|
TRACKING_SCOPE_KIND_USER, TRACKING_SCOPE_KIND_WORK, WechatMiniProgramPaymentParamsResponse,
|
|
WechatMiniProgramVirtualPayParamsResponse, WechatProfileRechargeOrderDoneEvent,
|
|
WechatProfileRechargeOrderErrorEvent,
|
|
};
|
|
use shared_kernel::{offset_datetime_to_unix_micros, parse_rfc3339};
|
|
use spacetime_client::SpacetimeClientError;
|
|
use std::{convert::Infallible, time::Duration};
|
|
use time::OffsetDateTime;
|
|
|
|
use crate::{
|
|
admin::AuthenticatedAdmin,
|
|
api_response::json_success_body,
|
|
auth::AuthenticatedAccessToken,
|
|
http_error::AppError,
|
|
request_context::RequestContext,
|
|
state::AppState,
|
|
wechat::pay::{
|
|
build_wechat_payment_request, build_wechat_web_payment_request, current_unix_micros,
|
|
map_wechat_pay_error,
|
|
},
|
|
};
|
|
|
|
type HmacSha256 = Hmac<Sha256>;
|
|
|
|
pub async fn get_profile_dashboard(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let record = state
|
|
.spacetime_client()
|
|
.get_profile_dashboard(user_id)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
ProfileDashboardSummaryResponse {
|
|
wallet_balance: record.wallet_balance,
|
|
total_play_time_ms: record.total_play_time_ms,
|
|
played_world_count: record.played_world_count,
|
|
updated_at: record.updated_at,
|
|
},
|
|
))
|
|
}
|
|
|
|
pub async fn get_profile_wallet_ledger(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let entries = state
|
|
.spacetime_client()
|
|
.list_profile_wallet_ledger(user_id)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
ProfileWalletLedgerResponse {
|
|
entries: entries
|
|
.into_iter()
|
|
.map(build_profile_wallet_ledger_entry_response)
|
|
.collect(),
|
|
},
|
|
))
|
|
}
|
|
|
|
fn format_profile_wallet_ledger_source_type(
|
|
source_type: RuntimeProfileWalletLedgerSourceType,
|
|
) -> &'static str {
|
|
match source_type {
|
|
RuntimeProfileWalletLedgerSourceType::SnapshotSync => {
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_SNAPSHOT_SYNC
|
|
}
|
|
RuntimeProfileWalletLedgerSourceType::NewUserRegistrationReward => {
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_NEW_USER_REGISTRATION_REWARD
|
|
}
|
|
RuntimeProfileWalletLedgerSourceType::InviteInviterReward => {
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_INVITE_INVITER_REWARD
|
|
}
|
|
RuntimeProfileWalletLedgerSourceType::InviteInviteeReward => {
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_INVITE_INVITEE_REWARD
|
|
}
|
|
RuntimeProfileWalletLedgerSourceType::PointsRecharge => {
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_POINTS_RECHARGE
|
|
}
|
|
RuntimeProfileWalletLedgerSourceType::AssetOperationConsume => {
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_ASSET_OPERATION_CONSUME
|
|
}
|
|
RuntimeProfileWalletLedgerSourceType::AssetOperationRefund => {
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_ASSET_OPERATION_REFUND
|
|
}
|
|
RuntimeProfileWalletLedgerSourceType::RedeemCodeReward => {
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_REDEEM_CODE_REWARD
|
|
}
|
|
RuntimeProfileWalletLedgerSourceType::PuzzleAuthorIncentiveClaim => {
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_PUZZLE_AUTHOR_INCENTIVE_CLAIM
|
|
}
|
|
RuntimeProfileWalletLedgerSourceType::DailyTaskReward => {
|
|
PROFILE_WALLET_LEDGER_SOURCE_TYPE_DAILY_TASK_REWARD
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn get_profile_recharge_center(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let record = state
|
|
.spacetime_client()
|
|
.get_profile_recharge_center(user_id)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_profile_recharge_center_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn create_profile_recharge_order(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
headers: HeaderMap,
|
|
Json(payload): Json<CreateProfileRechargeOrderRequest>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let payment_channel = normalize_recharge_payment_channel(payload.payment_channel)
|
|
.map_err(|error| runtime_profile_error_response(&request_context, error))?;
|
|
validate_recharge_device_for_payment_channel(authenticated.claims(), &payment_channel)
|
|
.map_err(|error| runtime_profile_error_response(&request_context, error))?;
|
|
validate_recharge_payment_channel(&state, &payment_channel)
|
|
.map_err(|error| runtime_profile_error_response(&request_context, error))?;
|
|
let created_at_micros = current_unix_micros();
|
|
let (center, order) = state
|
|
.spacetime_client()
|
|
.create_profile_recharge_order(
|
|
user_id,
|
|
payload.product_id,
|
|
payment_channel.clone(),
|
|
created_at_micros,
|
|
)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
let wechat_mini_program_pay_params = if payment_channel
|
|
== PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM
|
|
{
|
|
let identity = resolve_wechat_identity_for_payment(&state, &order.user_id)
|
|
.await
|
|
.map_err(|error| runtime_profile_error_response(&request_context, error))?;
|
|
Some(WechatMiniProgramPaymentParamsResponse::Ordinary(
|
|
state
|
|
.wechat_pay_client()
|
|
.create_mini_program_order(build_wechat_payment_request(
|
|
order.order_id.clone(),
|
|
order.product_title.clone(),
|
|
order.amount_cents,
|
|
identity,
|
|
))
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(&request_context, map_wechat_pay_error(error))
|
|
})?,
|
|
))
|
|
} else if payment_channel == PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM_VIRTUAL {
|
|
let openid = resolve_wechat_identity_for_payment(&state, &order.user_id)
|
|
.await
|
|
.map_err(|error| runtime_profile_error_response(&request_context, error))?;
|
|
Some(
|
|
build_wechat_virtual_pay_params(&state, ¢er, &order, &openid)
|
|
.map(WechatMiniProgramPaymentParamsResponse::Virtual)
|
|
.map_err(|error| runtime_profile_error_response(&request_context, error))?,
|
|
)
|
|
} else {
|
|
None
|
|
};
|
|
let wechat_h5_payment = if payment_channel == PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_H5 {
|
|
Some(
|
|
state
|
|
.wechat_pay_client()
|
|
.create_h5_order(build_wechat_web_payment_request(
|
|
order.order_id.clone(),
|
|
order.product_title.clone(),
|
|
order.amount_cents,
|
|
resolve_wechat_pay_client_ip(&headers),
|
|
))
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(&request_context, map_wechat_pay_error(error))
|
|
})?,
|
|
)
|
|
} else {
|
|
None
|
|
};
|
|
let wechat_native_payment = if payment_channel == PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_NATIVE
|
|
{
|
|
Some(
|
|
state
|
|
.wechat_pay_client()
|
|
.create_native_order(build_wechat_web_payment_request(
|
|
order.order_id.clone(),
|
|
order.product_title.clone(),
|
|
order.amount_cents,
|
|
resolve_wechat_pay_client_ip(&headers),
|
|
))
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(&request_context, map_wechat_pay_error(error))
|
|
})?,
|
|
)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
CreateProfileRechargeOrderResponse {
|
|
order: build_profile_recharge_order_response(order),
|
|
center: build_profile_recharge_center_response(center),
|
|
wechat_mini_program_pay_params,
|
|
wechat_h5_payment,
|
|
wechat_native_payment,
|
|
},
|
|
))
|
|
}
|
|
|
|
pub async fn confirm_wechat_profile_recharge_order(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
Path(order_id): Path<String>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let (center, order) = state
|
|
.spacetime_client()
|
|
.get_profile_recharge_order(order_id.clone())
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
if order.user_id != user_id {
|
|
return Err(runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::NOT_FOUND).with_message("充值订单不存在"),
|
|
));
|
|
}
|
|
if !is_wechat_recharge_payment_channel(&order.payment_channel) {
|
|
return Err(runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("该充值订单不是微信支付订单"),
|
|
));
|
|
}
|
|
if order.status == RuntimeProfileRechargeOrderStatus::Paid {
|
|
return Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_wechat_profile_recharge_order_confirmation(center, order),
|
|
));
|
|
}
|
|
if order.status != RuntimeProfileRechargeOrderStatus::Pending {
|
|
return Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_wechat_profile_recharge_order_confirmation(center, order),
|
|
));
|
|
}
|
|
if order.payment_channel == PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM_VIRTUAL {
|
|
return Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_wechat_profile_recharge_order_confirmation(center, order),
|
|
));
|
|
}
|
|
|
|
let wechat_order = state
|
|
.wechat_pay_client()
|
|
.query_order_by_out_trade_no(&order.order_id)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(&request_context, map_wechat_pay_error(error))
|
|
})?;
|
|
if wechat_order.out_trade_no != order.order_id {
|
|
return Err(runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::BAD_GATEWAY)
|
|
.with_message("微信支付查单返回的商户订单号与本地订单不一致")
|
|
.with_details(json!({ "provider": "wechat_pay" })),
|
|
));
|
|
}
|
|
if wechat_order.trade_state != "SUCCESS" {
|
|
return Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_wechat_profile_recharge_order_confirmation(center, order),
|
|
));
|
|
}
|
|
|
|
let paid_at_micros = paid_at_micros_from_wechat_order(&wechat_order);
|
|
let (center, order) = state
|
|
.spacetime_client()
|
|
.mark_profile_recharge_order_paid(
|
|
wechat_order.out_trade_no,
|
|
paid_at_micros,
|
|
wechat_order.transaction_id,
|
|
)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_wechat_profile_recharge_order_confirmation(center, order),
|
|
))
|
|
}
|
|
|
|
pub async fn stream_wechat_profile_recharge_order_events(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
Path(order_id): Path<String>,
|
|
) -> Result<Response, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let (center, order) = load_user_wechat_profile_recharge_order(
|
|
&state,
|
|
&request_context,
|
|
user_id.clone(),
|
|
order_id.clone(),
|
|
)
|
|
.await?;
|
|
let stream_state = state.clone();
|
|
let stream_context = request_context.clone();
|
|
let stream = async_stream::stream! {
|
|
let initial_response = build_wechat_profile_recharge_order_confirmation(center, order.clone());
|
|
yield Ok::<Event, Infallible>(wechat_profile_recharge_sse_json_event(
|
|
"order",
|
|
&initial_response,
|
|
));
|
|
if order.status != RuntimeProfileRechargeOrderStatus::Pending {
|
|
yield Ok::<Event, Infallible>(wechat_profile_recharge_sse_json_event(
|
|
"done",
|
|
&WechatProfileRechargeOrderDoneEvent {
|
|
order_id: order.order_id.clone(),
|
|
status: build_profile_recharge_order_status(order.status),
|
|
},
|
|
));
|
|
return;
|
|
}
|
|
|
|
let mut updates = stream_state.subscribe_profile_recharge_order_updates();
|
|
let mut poll_interval = tokio::time::interval(Duration::from_millis(1200));
|
|
for _ in 0..25 {
|
|
tokio::select! {
|
|
maybe_order_id = updates.recv() => {
|
|
if !matches!(maybe_order_id, Ok(ref value) if value == &order_id) {
|
|
continue;
|
|
}
|
|
}
|
|
_ = poll_interval.tick() => {}
|
|
}
|
|
|
|
match load_user_wechat_profile_recharge_order(
|
|
&stream_state,
|
|
&stream_context,
|
|
user_id.clone(),
|
|
order_id.clone(),
|
|
).await {
|
|
Ok((center, order)) => {
|
|
let response = build_wechat_profile_recharge_order_confirmation(center, order.clone());
|
|
yield Ok::<Event, Infallible>(wechat_profile_recharge_sse_json_event(
|
|
"order",
|
|
&response,
|
|
));
|
|
if order.status != RuntimeProfileRechargeOrderStatus::Pending {
|
|
yield Ok::<Event, Infallible>(wechat_profile_recharge_sse_json_event(
|
|
"done",
|
|
&WechatProfileRechargeOrderDoneEvent {
|
|
order_id: order.order_id.clone(),
|
|
status: build_profile_recharge_order_status(order.status),
|
|
},
|
|
));
|
|
return;
|
|
}
|
|
}
|
|
Err(_) => {
|
|
yield Ok::<Event, Infallible>(wechat_profile_recharge_sse_json_event(
|
|
"error",
|
|
&WechatProfileRechargeOrderErrorEvent {
|
|
message: "读取充值订单状态失败".to_string(),
|
|
},
|
|
));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
Ok(Sse::new(stream).into_response())
|
|
}
|
|
|
|
pub async fn submit_profile_feedback(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
Json(payload): Json<SubmitProfileFeedbackRequest>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let created_at_micros = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000;
|
|
let evidence_items = payload
|
|
.evidence_items
|
|
.into_iter()
|
|
.map(|item| RuntimeProfileFeedbackEvidenceSnapshot {
|
|
evidence_id: String::new(),
|
|
file_name: item.file_name,
|
|
content_type: item.content_type,
|
|
size_bytes: item.size_bytes,
|
|
data_url: item.data_url,
|
|
})
|
|
.collect();
|
|
|
|
let record = state
|
|
.spacetime_client()
|
|
.submit_profile_feedback(
|
|
user_id,
|
|
payload.description,
|
|
payload.contact_phone,
|
|
evidence_items,
|
|
created_at_micros as i64,
|
|
)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
SubmitProfileFeedbackResponse {
|
|
feedback: build_profile_feedback_submission_response(record),
|
|
},
|
|
))
|
|
}
|
|
|
|
pub async fn get_profile_referral_invite_center(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let record = state
|
|
.spacetime_client()
|
|
.get_profile_referral_invite_center(user_id)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_profile_referral_invite_center_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn redeem_profile_referral_invite_code(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
Json(payload): Json<RedeemProfileReferralInviteCodeRequest>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let updated_at_micros = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000;
|
|
let record = state
|
|
.spacetime_client()
|
|
.redeem_profile_referral_invite_code(user_id, payload.invite_code, updated_at_micros as i64)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_redeem_profile_referral_invite_code_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn redeem_profile_reward_code(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
Json(payload): Json<RedeemProfileRewardCodeRequest>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let redeemed_at_micros = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000;
|
|
let record = state
|
|
.spacetime_client()
|
|
.redeem_profile_reward_code(user_id, payload.code, redeemed_at_micros as i64)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_redeem_profile_reward_code_response(record),
|
|
))
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct AnalyticsMetricQueryParams {
|
|
pub event_key: String,
|
|
pub scope_kind: String,
|
|
pub scope_id: String,
|
|
pub granularity: String,
|
|
}
|
|
|
|
pub async fn get_profile_analytics_metric(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(_authenticated): Extension<AuthenticatedAccessToken>,
|
|
Query(query): Query<AnalyticsMetricQueryParams>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let scope_kind = parse_tracking_scope_kind(&query.scope_kind).map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::BAD_REQUEST).with_message(error),
|
|
)
|
|
})?;
|
|
let granularity = parse_analytics_granularity(&query.granularity).map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::BAD_REQUEST).with_message(error),
|
|
)
|
|
})?;
|
|
|
|
let record = state
|
|
.spacetime_client()
|
|
.query_analytics_metric(query.event_key, scope_kind, query.scope_id, granularity)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_analytics_metric_query_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn get_profile_task_center(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let record = state
|
|
.spacetime_client()
|
|
.get_profile_task_center(user_id)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_profile_task_center_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn claim_profile_task_reward(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
Path(task_id): Path<String>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let record = state
|
|
.spacetime_client()
|
|
.claim_profile_task_reward(user_id, task_id)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_claim_profile_task_reward_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn admin_list_profile_task_configs(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(admin): Extension<AuthenticatedAdmin>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let entries = state
|
|
.spacetime_client()
|
|
.admin_list_profile_task_configs(admin.session().subject.clone())
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
ProfileTaskConfigAdminListResponse {
|
|
entries: entries
|
|
.into_iter()
|
|
.map(build_profile_task_config_admin_response)
|
|
.collect(),
|
|
},
|
|
))
|
|
}
|
|
|
|
pub async fn admin_upsert_profile_task_config(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(admin): Extension<AuthenticatedAdmin>,
|
|
Json(payload): Json<AdminUpsertProfileTaskConfigRequest>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let cycle = parse_profile_task_cycle(&payload.cycle).map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::BAD_REQUEST).with_message(error),
|
|
)
|
|
})?;
|
|
let scope_kind = parse_tracking_scope_kind(&payload.scope_kind).map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::BAD_REQUEST).with_message(error),
|
|
)
|
|
})?;
|
|
// 中文注释：个人任务配置首版只开放 User scope，HTTP 层先返回清晰错误，领域层再兜底。
|
|
if scope_kind != RuntimeTrackingScopeKind::User {
|
|
return Err(runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("个人任务 scopeKind 首版仅支持 user"),
|
|
));
|
|
}
|
|
let updated_at_micros = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000;
|
|
let record = state
|
|
.spacetime_client()
|
|
.admin_upsert_profile_task_config(
|
|
admin.session().subject.clone(),
|
|
payload.task_id,
|
|
payload.title,
|
|
payload.description.unwrap_or_default(),
|
|
payload.event_key,
|
|
cycle,
|
|
scope_kind,
|
|
payload.threshold,
|
|
payload.reward_points,
|
|
payload.enabled,
|
|
payload.sort_order.unwrap_or(10),
|
|
updated_at_micros as i64,
|
|
)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_profile_task_config_admin_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn admin_disable_profile_task_config(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(admin): Extension<AuthenticatedAdmin>,
|
|
Json(payload): Json<AdminDisableProfileTaskConfigRequest>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let updated_at_micros = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000;
|
|
let record = state
|
|
.spacetime_client()
|
|
.admin_disable_profile_task_config(
|
|
admin.session().subject.clone(),
|
|
payload.task_id,
|
|
updated_at_micros as i64,
|
|
)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_profile_task_config_admin_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn admin_list_profile_recharge_products(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(admin): Extension<AuthenticatedAdmin>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let entries = state
|
|
.spacetime_client()
|
|
.admin_list_profile_recharge_products(admin.session().subject.clone())
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
ProfileRechargeProductConfigAdminListResponse {
|
|
entries: entries
|
|
.into_iter()
|
|
.map(build_profile_recharge_product_config_admin_response)
|
|
.collect(),
|
|
},
|
|
))
|
|
}
|
|
|
|
pub async fn admin_upsert_profile_recharge_product(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(admin): Extension<AuthenticatedAdmin>,
|
|
Json(payload): Json<AdminUpsertProfileRechargeProductRequest>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let kind = parse_profile_recharge_product_kind(&payload.kind).map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::BAD_REQUEST).with_message(error),
|
|
)
|
|
})?;
|
|
let tier = parse_profile_membership_tier(&payload.tier).map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::BAD_REQUEST).with_message(error),
|
|
)
|
|
})?;
|
|
let updated_at_micros = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000;
|
|
let record = state
|
|
.spacetime_client()
|
|
.admin_upsert_profile_recharge_product(
|
|
admin.session().subject.clone(),
|
|
payload.product_id,
|
|
payload.title,
|
|
payload.price_cents,
|
|
kind,
|
|
payload.points_amount,
|
|
payload.bonus_points,
|
|
payload.duration_days,
|
|
payload.badge_label.unwrap_or_default(),
|
|
payload.description.unwrap_or_default(),
|
|
tier,
|
|
payload.enabled,
|
|
payload.sort_order.unwrap_or(10),
|
|
updated_at_micros as i64,
|
|
)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_profile_recharge_product_config_admin_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn admin_list_profile_redeem_codes(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(admin): Extension<AuthenticatedAdmin>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let entries = state
|
|
.spacetime_client()
|
|
.admin_list_profile_redeem_codes(admin.session().subject.clone())
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
ProfileRedeemCodeAdminListResponse {
|
|
entries: entries
|
|
.into_iter()
|
|
.map(build_profile_redeem_code_admin_response)
|
|
.collect(),
|
|
},
|
|
))
|
|
}
|
|
|
|
pub async fn admin_upsert_profile_redeem_code(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(admin): Extension<AuthenticatedAdmin>,
|
|
Json(payload): Json<AdminUpsertProfileRedeemCodeRequest>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let updated_at_micros = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000;
|
|
let mode = parse_profile_redeem_code_mode(&payload.mode).map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
AppError::from_status(StatusCode::BAD_REQUEST).with_message(error),
|
|
)
|
|
})?;
|
|
let record = state
|
|
.spacetime_client()
|
|
.admin_upsert_profile_redeem_code(
|
|
admin.session().subject.clone(),
|
|
payload.code,
|
|
mode,
|
|
payload.reward_points,
|
|
payload.max_uses,
|
|
payload.enabled,
|
|
payload.allowed_user_ids,
|
|
payload.allowed_public_user_codes,
|
|
updated_at_micros as i64,
|
|
)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_profile_redeem_code_admin_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn admin_disable_profile_redeem_code(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(admin): Extension<AuthenticatedAdmin>,
|
|
Json(payload): Json<AdminDisableProfileRedeemCodeRequest>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let updated_at_micros = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000;
|
|
let record = state
|
|
.spacetime_client()
|
|
.admin_disable_profile_redeem_code(
|
|
admin.session().subject.clone(),
|
|
payload.code,
|
|
updated_at_micros as i64,
|
|
)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_profile_redeem_code_admin_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn admin_list_profile_invite_codes(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(admin): Extension<AuthenticatedAdmin>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let entries = state
|
|
.spacetime_client()
|
|
.admin_list_profile_invite_codes(admin.session().subject.clone())
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
ProfileInviteCodeAdminListResponse {
|
|
entries: entries
|
|
.into_iter()
|
|
.map(build_profile_invite_code_admin_response)
|
|
.collect(),
|
|
},
|
|
))
|
|
}
|
|
|
|
pub async fn admin_upsert_profile_invite_code(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(admin): Extension<AuthenticatedAdmin>,
|
|
Json(payload): Json<AdminUpsertProfileInviteCodeRequest>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let metadata_json = normalize_admin_invite_code_metadata(payload.metadata)
|
|
.map_err(|error| runtime_profile_error_response(&request_context, error))?;
|
|
let starts_at_micros = parse_admin_invite_code_time_field("startsAt", payload.starts_at)
|
|
.map_err(|error| runtime_profile_error_response(&request_context, error))?;
|
|
let expires_at_micros = parse_admin_invite_code_time_field("expiresAt", payload.expires_at)
|
|
.map_err(|error| runtime_profile_error_response(&request_context, error))?;
|
|
let updated_at_micros = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000;
|
|
let record = state
|
|
.spacetime_client()
|
|
.admin_upsert_profile_invite_code(
|
|
admin.session().username.clone(),
|
|
payload.invite_code,
|
|
metadata_json,
|
|
starts_at_micros,
|
|
expires_at_micros,
|
|
updated_at_micros as i64,
|
|
)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
build_profile_invite_code_admin_response(record),
|
|
))
|
|
}
|
|
|
|
pub async fn get_profile_play_stats(
|
|
State(state): State<AppState>,
|
|
Extension(request_context): Extension<RequestContext>,
|
|
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
|
) -> Result<Json<Value>, Response> {
|
|
let user_id = authenticated.claims().user_id().to_string();
|
|
let record = state
|
|
.spacetime_client()
|
|
.get_profile_play_stats(user_id)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(
|
|
&request_context,
|
|
map_runtime_profile_client_error(error),
|
|
)
|
|
})?;
|
|
|
|
Ok(json_success_body(
|
|
Some(&request_context),
|
|
ProfilePlayStatsResponse {
|
|
total_play_time_ms: record.total_play_time_ms,
|
|
played_works: record
|
|
.played_works
|
|
.into_iter()
|
|
.map(|entry| ProfilePlayedWorkSummaryResponse {
|
|
world_key: entry.world_key,
|
|
owner_user_id: entry.owner_user_id,
|
|
profile_id: entry.profile_id,
|
|
world_type: entry.world_type,
|
|
world_title: entry.world_title,
|
|
world_subtitle: entry.world_subtitle,
|
|
first_played_at: entry.first_played_at,
|
|
last_played_at: entry.last_played_at,
|
|
last_observed_play_time_ms: entry.last_observed_play_time_ms,
|
|
})
|
|
.collect(),
|
|
updated_at: record.updated_at,
|
|
},
|
|
))
|
|
}
|
|
|
|
fn map_runtime_profile_client_error(error: SpacetimeClientError) -> AppError {
|
|
let (status, provider) = match error {
|
|
SpacetimeClientError::Runtime(_) => (StatusCode::BAD_REQUEST, "runtime-profile"),
|
|
_ => (StatusCode::BAD_GATEWAY, "spacetimedb"),
|
|
};
|
|
|
|
AppError::from_status(status).with_details(json!({
|
|
"provider": provider,
|
|
"message": error.to_string(),
|
|
}))
|
|
}
|
|
|
|
fn runtime_profile_error_response(request_context: &RequestContext, error: AppError) -> Response {
|
|
error.into_response_with_context(Some(request_context))
|
|
}
|
|
|
|
async fn load_user_wechat_profile_recharge_order(
|
|
state: &AppState,
|
|
request_context: &RequestContext,
|
|
user_id: String,
|
|
order_id: String,
|
|
) -> Result<
|
|
(
|
|
RuntimeProfileRechargeCenterRecord,
|
|
RuntimeProfileRechargeOrderRecord,
|
|
),
|
|
Response,
|
|
> {
|
|
let (center, order) = state
|
|
.spacetime_client()
|
|
.get_profile_recharge_order(order_id)
|
|
.await
|
|
.map_err(|error| {
|
|
runtime_profile_error_response(request_context, map_runtime_profile_client_error(error))
|
|
})?;
|
|
|
|
if order.user_id != user_id {
|
|
return Err(runtime_profile_error_response(
|
|
request_context,
|
|
AppError::from_status(StatusCode::NOT_FOUND).with_message("充值订单不存在"),
|
|
));
|
|
}
|
|
if !is_wechat_recharge_payment_channel(&order.payment_channel) {
|
|
return Err(runtime_profile_error_response(
|
|
request_context,
|
|
AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("该充值订单不是微信支付订单"),
|
|
));
|
|
}
|
|
|
|
Ok((center, order))
|
|
}
|
|
|
|
fn build_wechat_profile_recharge_order_confirmation(
|
|
center: RuntimeProfileRechargeCenterRecord,
|
|
order: RuntimeProfileRechargeOrderRecord,
|
|
) -> ConfirmWechatProfileRechargeOrderResponse {
|
|
ConfirmWechatProfileRechargeOrderResponse {
|
|
order: build_profile_recharge_order_response(order),
|
|
center: build_profile_recharge_center_response(center),
|
|
}
|
|
}
|
|
|
|
fn build_profile_recharge_order_status(status: RuntimeProfileRechargeOrderStatus) -> String {
|
|
match status {
|
|
RuntimeProfileRechargeOrderStatus::Pending => "pending",
|
|
RuntimeProfileRechargeOrderStatus::Paid => "paid",
|
|
RuntimeProfileRechargeOrderStatus::Failed => "failed",
|
|
RuntimeProfileRechargeOrderStatus::Closed => "closed",
|
|
RuntimeProfileRechargeOrderStatus::Refunded => "refunded",
|
|
}
|
|
.to_string()
|
|
}
|
|
|
|
fn wechat_profile_recharge_sse_json_event<T>(event_name: &str, payload: &T) -> Event
|
|
where
|
|
T: Serialize,
|
|
{
|
|
Event::default()
|
|
.event(event_name)
|
|
.json_data(payload)
|
|
.unwrap_or_else(|_| {
|
|
Event::default()
|
|
.event("error")
|
|
.json_data(&WechatProfileRechargeOrderErrorEvent {
|
|
message: "充值订单状态事件序列化失败".to_string(),
|
|
})
|
|
.unwrap_or_else(|_| Event::default().event("error").data("{}"))
|
|
})
|
|
}
|
|
|
|
fn normalize_recharge_payment_channel(raw: Option<String>) -> Result<String, AppError> {
|
|
raw.map(|value| value.trim().to_string())
|
|
.filter(|value| !value.is_empty())
|
|
.ok_or_else(|| {
|
|
AppError::from_status(StatusCode::BAD_REQUEST).with_message("充值支付渠道不能为空")
|
|
})
|
|
}
|
|
|
|
fn validate_recharge_payment_channel(
|
|
state: &AppState,
|
|
payment_channel: &str,
|
|
) -> Result<(), AppError> {
|
|
if payment_channel == PROFILE_RECHARGE_PAYMENT_CHANNEL_MOCK {
|
|
if is_recharge_mock_channel_allowed(state) {
|
|
return Ok(());
|
|
}
|
|
|
|
return Err(AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("生产充值不允许使用 mock 支付渠道"));
|
|
}
|
|
|
|
if is_wechat_recharge_payment_channel(payment_channel) {
|
|
validate_real_wechat_recharge_payment_provider(state)?;
|
|
return Ok(());
|
|
}
|
|
|
|
Err(AppError::from_status(StatusCode::BAD_REQUEST).with_message("充值支付渠道无效"))
|
|
}
|
|
|
|
fn validate_recharge_device_for_payment_channel(
|
|
claims: &platform_auth::AccessTokenClaims,
|
|
payment_channel: &str,
|
|
) -> Result<(), AppError> {
|
|
if payment_channel == PROFILE_RECHARGE_PAYMENT_CHANNEL_MOCK {
|
|
return Ok(());
|
|
}
|
|
|
|
if !is_wechat_recharge_payment_channel(payment_channel) {
|
|
return Ok(());
|
|
}
|
|
|
|
let is_supported_device = match payment_channel {
|
|
PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM => {
|
|
claims.is_wechat_mini_program_device()
|
|
}
|
|
PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM_VIRTUAL => {
|
|
claims.is_wechat_mini_program_device()
|
|
}
|
|
PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_H5 => claims.is_mobile_wechat_browser_device(),
|
|
PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_NATIVE => claims.is_desktop_wechat_browser_device(),
|
|
_ => false,
|
|
};
|
|
if is_supported_device {
|
|
return Ok(());
|
|
}
|
|
|
|
Err(AppError::from_status(StatusCode::FORBIDDEN)
|
|
.with_message("当前登录设备不支持充值，请在微信环境内登录后重试"))
|
|
}
|
|
|
|
fn validate_real_wechat_recharge_payment_provider(state: &AppState) -> Result<(), AppError> {
|
|
if !state.config.wechat_pay_enabled {
|
|
return Err(AppError::from_status(StatusCode::SERVICE_UNAVAILABLE)
|
|
.with_message("微信支付真实渠道暂未启用"));
|
|
}
|
|
|
|
if state
|
|
.config
|
|
.wechat_pay_provider
|
|
.trim()
|
|
.eq_ignore_ascii_case("real")
|
|
{
|
|
return Ok(());
|
|
}
|
|
|
|
Err(AppError::from_status(StatusCode::SERVICE_UNAVAILABLE)
|
|
.with_message("真实微信支付渠道不能使用 mock 支付配置"))
|
|
}
|
|
|
|
fn is_recharge_mock_channel_allowed(state: &AppState) -> bool {
|
|
if cfg!(test) {
|
|
return state
|
|
.config
|
|
.wechat_pay_provider
|
|
.trim()
|
|
.eq_ignore_ascii_case(PROFILE_RECHARGE_PAYMENT_CHANNEL_MOCK);
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
fn is_wechat_recharge_payment_channel(payment_channel: &str) -> bool {
|
|
matches!(
|
|
payment_channel,
|
|
PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM
|
|
| PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM_VIRTUAL
|
|
| PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_H5
|
|
| PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_NATIVE
|
|
)
|
|
}
|
|
|
|
fn resolve_wechat_pay_client_ip(headers: &HeaderMap) -> String {
|
|
headers
|
|
.get("x-forwarded-for")
|
|
.and_then(|value| value.to_str().ok())
|
|
.and_then(|value| value.split(',').next())
|
|
.map(str::trim)
|
|
.filter(|value| !value.is_empty())
|
|
.or_else(|| {
|
|
headers
|
|
.get("x-real-ip")
|
|
.and_then(|value| value.to_str().ok())
|
|
.map(str::trim)
|
|
.filter(|value| !value.is_empty())
|
|
})
|
|
.unwrap_or("127.0.0.1")
|
|
.to_string()
|
|
}
|
|
|
|
async fn resolve_wechat_identity_for_payment(
|
|
state: &AppState,
|
|
user_id: &str,
|
|
) -> Result<String, AppError> {
|
|
if let Some(identity) = state
|
|
.wechat_auth_service()
|
|
.get_identity_by_user_id(user_id)
|
|
.map_err(|error| {
|
|
AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
|
|
.with_message(format!("读取微信身份失败：{error}"))
|
|
})?
|
|
{
|
|
return Ok(identity.provider_uid);
|
|
}
|
|
|
|
Err(AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("当前账号缺少微信小程序身份，请在小程序内重新登录后再支付"))
|
|
}
|
|
|
|
fn build_wechat_virtual_pay_params(
|
|
state: &AppState,
|
|
center: &RuntimeProfileRechargeCenterRecord,
|
|
order: &RuntimeProfileRechargeOrderRecord,
|
|
openid: &str,
|
|
) -> Result<WechatMiniProgramVirtualPayParamsResponse, AppError> {
|
|
let product = match order.kind {
|
|
RuntimeProfileRechargeProductKind::Points => center
|
|
.point_products
|
|
.iter()
|
|
.find(|item| item.product_id == order.product_id)
|
|
.ok_or_else(|| {
|
|
AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("当前充值商品不存在，请刷新后再试")
|
|
})?,
|
|
RuntimeProfileRechargeProductKind::Membership => center
|
|
.membership_products
|
|
.iter()
|
|
.find(|item| item.product_id == order.product_id)
|
|
.ok_or_else(|| {
|
|
AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("当前充值商品不存在，请刷新后再试")
|
|
})?,
|
|
};
|
|
let identity = state
|
|
.wechat_auth_service()
|
|
.get_identity_by_user_id(&order.user_id)
|
|
.map_err(|error| {
|
|
AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
|
|
.with_message(format!("读取微信身份失败：{error}"))
|
|
})?
|
|
.ok_or_else(|| {
|
|
AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("当前账号缺少微信小程序身份，请在小程序内重新登录后再支付")
|
|
})?;
|
|
let session_key = identity.session_key.ok_or_else(|| {
|
|
AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("当前微信登录态缺少 session_key，请重新登录后再试")
|
|
})?;
|
|
let offer_id = required_wechat_virtual_payment_config(
|
|
state
|
|
.config
|
|
.wechat_mini_program_virtual_payment_offer_id
|
|
.as_deref(),
|
|
"微信虚拟支付 OfferId 未配置",
|
|
)?;
|
|
let mode = match order.kind {
|
|
RuntimeProfileRechargeProductKind::Points => "short_series_coin",
|
|
RuntimeProfileRechargeProductKind::Membership => "short_series_goods",
|
|
};
|
|
let buy_quantity = match product.kind {
|
|
RuntimeProfileRechargeProductKind::Points => product.points_amount,
|
|
RuntimeProfileRechargeProductKind::Membership => 1,
|
|
};
|
|
let mut sign_data = serde_json::json!({
|
|
"offerId": offer_id,
|
|
"buyQuantity": buy_quantity,
|
|
"env": state.config.wechat_mini_program_virtual_payment_env,
|
|
"currencyType": "CNY",
|
|
"outTradeNo": order.order_id,
|
|
"attach": serde_json::json!({
|
|
"userId": order.user_id,
|
|
"productId": order.product_id,
|
|
"paymentChannel": order.payment_channel,
|
|
"openId": openid,
|
|
}).to_string(),
|
|
});
|
|
if order.kind == RuntimeProfileRechargeProductKind::Membership {
|
|
sign_data["productId"] = json!(order.product_id);
|
|
sign_data["goodsPrice"] = json!(order.amount_cents);
|
|
}
|
|
let sign_data = sign_data.to_string();
|
|
let pay_sig = calc_wechat_virtual_payment_signature(state, &sign_data, false)?;
|
|
let signature = calc_wechat_virtual_payment_user_signature_with_key(&session_key, &sign_data)?;
|
|
|
|
Ok(WechatMiniProgramVirtualPayParamsResponse {
|
|
mode: mode.to_string(),
|
|
sign_data,
|
|
pay_sig,
|
|
signature,
|
|
})
|
|
}
|
|
|
|
fn calc_wechat_virtual_payment_signature(
|
|
state: &AppState,
|
|
sign_data: &str,
|
|
use_sandbox_key: bool,
|
|
) -> Result<String, AppError> {
|
|
let env = state.config.wechat_mini_program_virtual_payment_env;
|
|
let app_key = if use_sandbox_key || env == 1 {
|
|
required_wechat_virtual_payment_config(
|
|
state
|
|
.config
|
|
.wechat_mini_program_virtual_payment_sandbox_app_key
|
|
.as_deref(),
|
|
"微信虚拟支付沙箱 AppKey 未配置",
|
|
)?
|
|
} else {
|
|
required_wechat_virtual_payment_config(
|
|
state
|
|
.config
|
|
.wechat_mini_program_virtual_payment_app_key
|
|
.as_deref(),
|
|
"微信虚拟支付 AppKey 未配置",
|
|
)?
|
|
};
|
|
calc_wechat_virtual_payment_pay_signature_with_key(app_key, sign_data)
|
|
}
|
|
|
|
fn required_wechat_virtual_payment_config<'a>(
|
|
value: Option<&'a str>,
|
|
message: &str,
|
|
) -> Result<&'a str, AppError> {
|
|
value
|
|
.map(str::trim)
|
|
.filter(|value| !value.is_empty())
|
|
.ok_or_else(|| AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_message(message))
|
|
}
|
|
|
|
fn calc_wechat_virtual_payment_pay_signature_with_key(
|
|
key: &str,
|
|
sign_data: &str,
|
|
) -> Result<String, AppError> {
|
|
let mut mac = HmacSha256::new_from_slice(key.as_bytes()).map_err(|_| {
|
|
AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
|
|
.with_message("微信虚拟支付签名密钥初始化失败")
|
|
})?;
|
|
mac.update(format!("requestVirtualPayment&{sign_data}").as_bytes());
|
|
Ok(to_lower_hex(mac.finalize().into_bytes().as_slice()))
|
|
}
|
|
|
|
fn calc_wechat_virtual_payment_user_signature_with_key(
|
|
session_key: &str,
|
|
sign_data: &str,
|
|
) -> Result<String, AppError> {
|
|
let mut mac = HmacSha256::new_from_slice(session_key.as_bytes()).map_err(|_| {
|
|
AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
|
|
.with_message("微信虚拟支付用户态签名密钥初始化失败")
|
|
})?;
|
|
mac.update(sign_data.as_bytes());
|
|
Ok(to_lower_hex(mac.finalize().into_bytes().as_slice()))
|
|
}
|
|
|
|
fn to_lower_hex(bytes: &[u8]) -> String {
|
|
const HEX: &[u8; 16] = b"0123456789abcdef";
|
|
let mut output = String::with_capacity(bytes.len() * 2);
|
|
for &byte in bytes {
|
|
output.push(char::from(HEX[(byte >> 4) as usize]));
|
|
output.push(char::from(HEX[(byte & 0x0f) as usize]));
|
|
}
|
|
output
|
|
}
|
|
|
|
fn paid_at_micros_from_wechat_order(order: &WechatPayNotifyOrder) -> i64 {
|
|
order
|
|
.success_time
|
|
.as_deref()
|
|
.and_then(|value| parse_rfc3339(value).ok())
|
|
.map(offset_datetime_to_unix_micros)
|
|
.unwrap_or_else(current_unix_micros)
|
|
}
|
|
|
|
fn build_profile_recharge_center_response(
|
|
record: RuntimeProfileRechargeCenterRecord,
|
|
) -> ProfileRechargeCenterResponse {
|
|
ProfileRechargeCenterResponse {
|
|
wallet_balance: record.wallet_balance,
|
|
membership: ProfileMembershipResponse {
|
|
status: record.membership.status.as_str().to_string(),
|
|
tier: record.membership.tier.as_str().to_string(),
|
|
started_at: record.membership.started_at,
|
|
expires_at: record.membership.expires_at,
|
|
updated_at: record.membership.updated_at,
|
|
},
|
|
point_products: record
|
|
.point_products
|
|
.into_iter()
|
|
.map(build_profile_recharge_product_response)
|
|
.collect(),
|
|
membership_products: record
|
|
.membership_products
|
|
.into_iter()
|
|
.map(build_profile_recharge_product_response)
|
|
.collect(),
|
|
benefits: record
|
|
.benefits
|
|
.into_iter()
|
|
.map(build_profile_membership_benefit_response)
|
|
.collect(),
|
|
latest_order: record
|
|
.latest_order
|
|
.map(build_profile_recharge_order_response),
|
|
has_points_recharged: record.has_points_recharged,
|
|
}
|
|
}
|
|
|
|
fn build_profile_recharge_product_response(
|
|
record: RuntimeProfileRechargeProductRecord,
|
|
) -> ProfileRechargeProductResponse {
|
|
ProfileRechargeProductResponse {
|
|
product_id: record.product_id,
|
|
title: record.title,
|
|
price_cents: record.price_cents,
|
|
kind: record.kind.as_str().to_string(),
|
|
points_amount: record.points_amount,
|
|
bonus_points: record.bonus_points,
|
|
duration_days: record.duration_days,
|
|
badge_label: record.badge_label,
|
|
description: record.description,
|
|
tier: record.tier.as_str().to_string(),
|
|
}
|
|
}
|
|
|
|
fn build_profile_membership_benefit_response(
|
|
record: RuntimeProfileMembershipBenefitRecord,
|
|
) -> ProfileMembershipBenefitResponse {
|
|
ProfileMembershipBenefitResponse {
|
|
benefit_name: record.benefit_name,
|
|
normal_value: record.normal_value,
|
|
month_value: record.month_value,
|
|
season_value: record.season_value,
|
|
year_value: record.year_value,
|
|
}
|
|
}
|
|
|
|
fn build_profile_recharge_order_response(
|
|
record: RuntimeProfileRechargeOrderRecord,
|
|
) -> ProfileRechargeOrderResponse {
|
|
ProfileRechargeOrderResponse {
|
|
order_id: record.order_id,
|
|
product_id: record.product_id,
|
|
product_title: record.product_title,
|
|
kind: record.kind.as_str().to_string(),
|
|
amount_cents: record.amount_cents,
|
|
status: record.status.as_str().to_string(),
|
|
payment_channel: record.payment_channel,
|
|
paid_at: record.paid_at,
|
|
provider_transaction_id: record.provider_transaction_id,
|
|
created_at: record.created_at,
|
|
points_delta: record.points_delta,
|
|
membership_expires_at: record.membership_expires_at,
|
|
}
|
|
}
|
|
|
|
fn build_profile_feedback_submission_response(
|
|
record: RuntimeProfileFeedbackSubmissionRecord,
|
|
) -> ProfileFeedbackSubmissionResponse {
|
|
ProfileFeedbackSubmissionResponse {
|
|
feedback_id: record.feedback_id,
|
|
status: match record.status {
|
|
module_runtime::RuntimeProfileFeedbackStatus::Open => {
|
|
PROFILE_FEEDBACK_STATUS_OPEN.to_string()
|
|
}
|
|
},
|
|
created_at: record.created_at,
|
|
evidence_items: record
|
|
.evidence_items
|
|
.into_iter()
|
|
.map(build_profile_feedback_evidence_response)
|
|
.collect(),
|
|
}
|
|
}
|
|
|
|
fn build_profile_feedback_evidence_response(
|
|
record: RuntimeProfileFeedbackEvidenceRecord,
|
|
) -> ProfileFeedbackEvidenceItemResponse {
|
|
ProfileFeedbackEvidenceItemResponse {
|
|
evidence_id: record.evidence_id,
|
|
file_name: record.file_name,
|
|
content_type: record.content_type,
|
|
size_bytes: record.size_bytes,
|
|
}
|
|
}
|
|
|
|
fn build_profile_referral_invite_center_response(
|
|
record: RuntimeReferralInviteCenterRecord,
|
|
) -> ProfileReferralInviteCenterResponse {
|
|
ProfileReferralInviteCenterResponse {
|
|
invite_code: record.invite_code,
|
|
invite_link_path: record.invite_link_path,
|
|
invited_count: record.invited_count,
|
|
rewarded_invite_count: record.rewarded_invite_count,
|
|
today_inviter_reward_count: record.today_inviter_reward_count,
|
|
today_inviter_reward_remaining: record.today_inviter_reward_remaining,
|
|
reward_points: record.reward_points,
|
|
invited_users: record
|
|
.invited_users
|
|
.into_iter()
|
|
.map(|user| ProfileReferralInvitedUserResponse {
|
|
user_id: user.user_id,
|
|
display_name: user.display_name,
|
|
avatar_url: user.avatar_url,
|
|
bound_at: user.bound_at,
|
|
})
|
|
.collect(),
|
|
has_redeemed_code: record.has_redeemed_code,
|
|
bound_inviter_user_id: record.bound_inviter_user_id,
|
|
bound_at: record.bound_at,
|
|
updated_at: record.updated_at,
|
|
}
|
|
}
|
|
|
|
fn build_redeem_profile_referral_invite_code_response(
|
|
record: module_runtime::RuntimeReferralRedeemRecord,
|
|
) -> RedeemProfileReferralInviteCodeResponse {
|
|
RedeemProfileReferralInviteCodeResponse {
|
|
center: build_profile_referral_invite_center_response(record.center),
|
|
invitee_reward_granted: record.invitee_reward_granted,
|
|
inviter_reward_granted: record.inviter_reward_granted,
|
|
invitee_balance_after: record.invitee_balance_after,
|
|
inviter_balance_after: record.inviter_balance_after,
|
|
}
|
|
}
|
|
|
|
fn build_redeem_profile_reward_code_response(
|
|
record: RuntimeProfileRewardCodeRedeemRecord,
|
|
) -> RedeemProfileRewardCodeResponse {
|
|
RedeemProfileRewardCodeResponse {
|
|
wallet_balance: record.wallet_balance,
|
|
amount_granted: record.amount_granted,
|
|
ledger_entry: build_profile_wallet_ledger_entry_response(record.ledger_entry),
|
|
}
|
|
}
|
|
|
|
fn build_profile_wallet_ledger_entry_response(
|
|
record: module_runtime::RuntimeProfileWalletLedgerEntryRecord,
|
|
) -> ProfileWalletLedgerEntryResponse {
|
|
ProfileWalletLedgerEntryResponse {
|
|
id: record.wallet_ledger_id,
|
|
amount_delta: record.amount_delta,
|
|
balance_after: record.balance_after,
|
|
source_type: format_profile_wallet_ledger_source_type(record.source_type).to_string(),
|
|
created_at: record.created_at,
|
|
}
|
|
}
|
|
|
|
fn build_profile_task_center_response(
|
|
record: RuntimeProfileTaskCenterRecord,
|
|
) -> ProfileTaskCenterResponse {
|
|
ProfileTaskCenterResponse {
|
|
day_key: record.day_key,
|
|
wallet_balance: record.wallet_balance,
|
|
tasks: record
|
|
.tasks
|
|
.into_iter()
|
|
.map(build_profile_task_item_response)
|
|
.collect(),
|
|
updated_at: record.updated_at,
|
|
}
|
|
}
|
|
|
|
fn build_analytics_metric_query_response(
|
|
record: module_runtime::AnalyticsMetricQueryResponse,
|
|
) -> AnalyticsMetricQueryResponse {
|
|
AnalyticsMetricQueryResponse {
|
|
buckets: record
|
|
.buckets
|
|
.into_iter()
|
|
.map(|bucket| AnalyticsBucketMetricResponse {
|
|
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,
|
|
})
|
|
.collect(),
|
|
}
|
|
}
|
|
|
|
fn build_profile_task_item_response(
|
|
record: RuntimeProfileTaskItemRecord,
|
|
) -> ProfileTaskItemResponse {
|
|
ProfileTaskItemResponse {
|
|
task_id: record.task_id,
|
|
title: record.title,
|
|
description: record.description,
|
|
event_key: record.event_key,
|
|
cycle: format_profile_task_cycle(record.cycle).to_string(),
|
|
threshold: record.threshold,
|
|
progress_count: record.progress_count,
|
|
reward_points: record.reward_points,
|
|
status: format_profile_task_status(record.status).to_string(),
|
|
day_key: record.day_key,
|
|
claimed_at: record.claimed_at,
|
|
updated_at: record.updated_at,
|
|
}
|
|
}
|
|
|
|
fn build_claim_profile_task_reward_response(
|
|
record: RuntimeProfileTaskClaimRecord,
|
|
) -> ClaimProfileTaskRewardResponse {
|
|
ClaimProfileTaskRewardResponse {
|
|
task_id: record.task_id,
|
|
day_key: record.day_key,
|
|
reward_points: record.reward_points,
|
|
wallet_balance: record.wallet_balance,
|
|
ledger_entry: build_profile_wallet_ledger_entry_response(record.ledger_entry),
|
|
center: build_profile_task_center_response(record.center),
|
|
}
|
|
}
|
|
|
|
fn build_profile_task_config_admin_response(
|
|
record: RuntimeProfileTaskConfigRecord,
|
|
) -> ProfileTaskConfigAdminResponse {
|
|
ProfileTaskConfigAdminResponse {
|
|
task_id: record.task_id,
|
|
title: record.title,
|
|
description: record.description,
|
|
event_key: record.event_key,
|
|
cycle: format_profile_task_cycle(record.cycle).to_string(),
|
|
scope_kind: format_tracking_scope_kind(record.scope_kind).to_string(),
|
|
threshold: record.threshold,
|
|
reward_points: record.reward_points,
|
|
enabled: record.enabled,
|
|
sort_order: record.sort_order,
|
|
created_by: record.created_by,
|
|
created_at: record.created_at,
|
|
updated_by: record.updated_by,
|
|
updated_at: record.updated_at,
|
|
}
|
|
}
|
|
|
|
fn build_profile_recharge_product_config_admin_response(
|
|
record: RuntimeProfileRechargeProductConfigRecord,
|
|
) -> ProfileRechargeProductConfigAdminResponse {
|
|
ProfileRechargeProductConfigAdminResponse {
|
|
product_id: record.product_id,
|
|
title: record.title,
|
|
price_cents: record.price_cents,
|
|
kind: format_profile_recharge_product_kind(record.kind).to_string(),
|
|
points_amount: record.points_amount,
|
|
bonus_points: record.bonus_points,
|
|
duration_days: record.duration_days,
|
|
badge_label: record.badge_label,
|
|
description: record.description,
|
|
tier: format_profile_membership_tier(record.tier).to_string(),
|
|
enabled: record.enabled,
|
|
sort_order: record.sort_order,
|
|
created_by: record.created_by,
|
|
created_at: record.created_at,
|
|
updated_by: record.updated_by,
|
|
updated_at: record.updated_at,
|
|
}
|
|
}
|
|
|
|
fn normalize_admin_invite_code_metadata(metadata: Option<Value>) -> Result<String, AppError> {
|
|
let metadata = match metadata {
|
|
Some(Value::Null) | None => json!({}),
|
|
Some(value) if value.is_object() => value,
|
|
Some(_) => {
|
|
return Err(AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("邀请码 metadata 必须是 JSON 对象")
|
|
.with_details(json!({ "field": "metadata" })));
|
|
}
|
|
};
|
|
let metadata_json = serde_json::to_string(&metadata).map_err(|error| {
|
|
AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message(format!("邀请码 metadata 序列化失败：{error}"))
|
|
.with_details(json!({ "field": "metadata" }))
|
|
})?;
|
|
if metadata_json.len() > 4096 {
|
|
return Err(AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message("邀请码 metadata 不能超过 4096 bytes")
|
|
.with_details(json!({ "field": "metadata" })));
|
|
}
|
|
|
|
Ok(metadata_json)
|
|
}
|
|
|
|
fn parse_admin_invite_code_time_field(
|
|
field: &'static str,
|
|
value: Option<String>,
|
|
) -> Result<Option<i64>, AppError> {
|
|
let Some(value) = value else {
|
|
return Ok(None);
|
|
};
|
|
let value = value.trim();
|
|
if value.is_empty() {
|
|
return Ok(None);
|
|
}
|
|
|
|
let parsed = parse_rfc3339(value).map_err(|error| {
|
|
AppError::from_status(StatusCode::BAD_REQUEST)
|
|
.with_message(format!("邀请码 {field} 必须是 RFC3339 时间字符串"))
|
|
.with_details(json!({ "field": field, "message": error }))
|
|
})?;
|
|
|
|
Ok(Some(offset_datetime_to_unix_micros(parsed)))
|
|
}
|
|
|
|
fn parse_profile_redeem_code_mode(raw: &str) -> Result<RuntimeProfileRedeemCodeMode, String> {
|
|
match raw.trim().to_ascii_lowercase().as_str() {
|
|
"public" => Ok(RuntimeProfileRedeemCodeMode::Public),
|
|
"unique" => Ok(RuntimeProfileRedeemCodeMode::Unique),
|
|
"private" => Ok(RuntimeProfileRedeemCodeMode::Private),
|
|
_ => Err("兑换码类型无效".to_string()),
|
|
}
|
|
}
|
|
|
|
fn parse_profile_task_cycle(raw: &str) -> Result<RuntimeProfileTaskCycle, String> {
|
|
match raw.trim().to_ascii_lowercase().as_str() {
|
|
PROFILE_TASK_CYCLE_DAILY => Ok(RuntimeProfileTaskCycle::Daily),
|
|
_ => Err("任务周期无效".to_string()),
|
|
}
|
|
}
|
|
|
|
fn parse_profile_recharge_product_kind(
|
|
raw: &str,
|
|
) -> Result<RuntimeProfileRechargeProductKind, String> {
|
|
match raw.trim().to_ascii_lowercase().as_str() {
|
|
PROFILE_RECHARGE_PRODUCT_KIND_POINTS => Ok(RuntimeProfileRechargeProductKind::Points),
|
|
PROFILE_RECHARGE_PRODUCT_KIND_MEMBERSHIP => {
|
|
Ok(RuntimeProfileRechargeProductKind::Membership)
|
|
}
|
|
_ => Err("充值商品类型无效".to_string()),
|
|
}
|
|
}
|
|
|
|
fn parse_profile_membership_tier(raw: &str) -> Result<RuntimeProfileMembershipTier, String> {
|
|
match raw.trim().to_ascii_lowercase().as_str() {
|
|
PROFILE_MEMBERSHIP_TIER_NORMAL => Ok(RuntimeProfileMembershipTier::Normal),
|
|
PROFILE_MEMBERSHIP_TIER_MONTH => Ok(RuntimeProfileMembershipTier::Month),
|
|
PROFILE_MEMBERSHIP_TIER_SEASON => Ok(RuntimeProfileMembershipTier::Season),
|
|
PROFILE_MEMBERSHIP_TIER_YEAR => Ok(RuntimeProfileMembershipTier::Year),
|
|
_ => Err("会员档位无效".to_string()),
|
|
}
|
|
}
|
|
|
|
fn parse_tracking_scope_kind(raw: &str) -> Result<RuntimeTrackingScopeKind, String> {
|
|
match raw.trim().to_ascii_lowercase().as_str() {
|
|
TRACKING_SCOPE_KIND_SITE => Ok(RuntimeTrackingScopeKind::Site),
|
|
TRACKING_SCOPE_KIND_WORK => Ok(RuntimeTrackingScopeKind::Work),
|
|
TRACKING_SCOPE_KIND_MODULE => Ok(RuntimeTrackingScopeKind::Module),
|
|
TRACKING_SCOPE_KIND_USER => Ok(RuntimeTrackingScopeKind::User),
|
|
_ => Err("埋点范围无效".to_string()),
|
|
}
|
|
}
|
|
|
|
fn parse_analytics_granularity(raw: &str) -> Result<AnalyticsGranularity, String> {
|
|
match raw.trim().to_ascii_lowercase().as_str() {
|
|
ANALYTICS_GRANULARITY_DAY => Ok(AnalyticsGranularity::Day),
|
|
ANALYTICS_GRANULARITY_WEEK => Ok(AnalyticsGranularity::Week),
|
|
ANALYTICS_GRANULARITY_MONTH => Ok(AnalyticsGranularity::Month),
|
|
ANALYTICS_GRANULARITY_QUARTER => Ok(AnalyticsGranularity::Quarter),
|
|
ANALYTICS_GRANULARITY_YEAR => Ok(AnalyticsGranularity::Year),
|
|
_ => Err("统计粒度无效".to_string()),
|
|
}
|
|
}
|
|
|
|
fn format_profile_task_cycle(cycle: RuntimeProfileTaskCycle) -> &'static str {
|
|
match cycle {
|
|
RuntimeProfileTaskCycle::Daily => PROFILE_TASK_CYCLE_DAILY,
|
|
}
|
|
}
|
|
|
|
fn format_profile_task_status(status: RuntimeProfileTaskStatus) -> &'static str {
|
|
match status {
|
|
RuntimeProfileTaskStatus::Incomplete => PROFILE_TASK_STATUS_INCOMPLETE,
|
|
RuntimeProfileTaskStatus::Claimable => PROFILE_TASK_STATUS_CLAIMABLE,
|
|
RuntimeProfileTaskStatus::Claimed => PROFILE_TASK_STATUS_CLAIMED,
|
|
RuntimeProfileTaskStatus::Disabled => PROFILE_TASK_STATUS_DISABLED,
|
|
}
|
|
}
|
|
|
|
fn format_profile_recharge_product_kind(kind: RuntimeProfileRechargeProductKind) -> &'static str {
|
|
match kind {
|
|
RuntimeProfileRechargeProductKind::Points => PROFILE_RECHARGE_PRODUCT_KIND_POINTS,
|
|
RuntimeProfileRechargeProductKind::Membership => PROFILE_RECHARGE_PRODUCT_KIND_MEMBERSHIP,
|
|
}
|
|
}
|
|
|
|
fn format_profile_membership_tier(tier: RuntimeProfileMembershipTier) -> &'static str {
|
|
match tier {
|
|
RuntimeProfileMembershipTier::Normal => PROFILE_MEMBERSHIP_TIER_NORMAL,
|
|
RuntimeProfileMembershipTier::Month => PROFILE_MEMBERSHIP_TIER_MONTH,
|
|
RuntimeProfileMembershipTier::Season => PROFILE_MEMBERSHIP_TIER_SEASON,
|
|
RuntimeProfileMembershipTier::Year => PROFILE_MEMBERSHIP_TIER_YEAR,
|
|
}
|
|
}
|
|
|
|
fn format_tracking_scope_kind(scope_kind: RuntimeTrackingScopeKind) -> &'static str {
|
|
match scope_kind {
|
|
RuntimeTrackingScopeKind::Site => TRACKING_SCOPE_KIND_SITE,
|
|
RuntimeTrackingScopeKind::Work => TRACKING_SCOPE_KIND_WORK,
|
|
RuntimeTrackingScopeKind::Module => TRACKING_SCOPE_KIND_MODULE,
|
|
RuntimeTrackingScopeKind::User => TRACKING_SCOPE_KIND_USER,
|
|
}
|
|
}
|
|
|
|
fn build_profile_invite_code_admin_response(
|
|
record: RuntimeProfileInviteCodeRecord,
|
|
) -> ProfileInviteCodeAdminResponse {
|
|
let metadata =
|
|
serde_json::from_str::<Value>(&record.metadata_json).unwrap_or_else(|_| json!({}));
|
|
ProfileInviteCodeAdminResponse {
|
|
user_id: record.user_id,
|
|
invite_code: record.invite_code,
|
|
metadata,
|
|
starts_at: record.starts_at,
|
|
expires_at: record.expires_at,
|
|
status: record.status.as_str().to_string(),
|
|
created_at: record.created_at,
|
|
updated_at: record.updated_at,
|
|
}
|
|
}
|
|
|
|
fn build_profile_redeem_code_admin_response(
|
|
record: RuntimeProfileRedeemCodeRecord,
|
|
) -> ProfileRedeemCodeAdminResponse {
|
|
ProfileRedeemCodeAdminResponse {
|
|
code: record.code,
|
|
mode: record.mode.as_str().to_string(),
|
|
reward_points: record.reward_points,
|
|
max_uses: record.max_uses,
|
|
global_used_count: record.global_used_count,
|
|
enabled: record.enabled,
|
|
allowed_user_ids: record.allowed_user_ids,
|
|
created_by: record.created_by,
|
|
created_at: record.created_at,
|
|
updated_at: record.updated_at,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use module_auth::{ResolveWechatLoginInput, WechatIdentityProfile};
|
|
use module_runtime::{
|
|
PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM_VIRTUAL,
|
|
RuntimeProfileMembershipRecord, RuntimeProfileMembershipStatus,
|
|
RuntimeProfileMembershipTier, RuntimeProfileRechargeCenterRecord,
|
|
RuntimeProfileRechargeOrderRecord, RuntimeProfileRechargeOrderStatus,
|
|
RuntimeProfileRechargeProductKind, RuntimeProfileRechargeProductRecord,
|
|
RuntimeProfileWalletLedgerSourceType,
|
|
};
|
|
|
|
use super::{
|
|
build_wechat_virtual_pay_params, calc_wechat_virtual_payment_pay_signature_with_key,
|
|
calc_wechat_virtual_payment_user_signature_with_key,
|
|
format_profile_wallet_ledger_source_type, normalize_admin_invite_code_metadata,
|
|
};
|
|
|
|
use axum::{
|
|
body::Body,
|
|
http::{Request, StatusCode},
|
|
};
|
|
use http_body_util::BodyExt;
|
|
use platform_auth::{
|
|
AccessTokenClaims, AccessTokenClaimsInput, AuthProvider, BindingStatus, sign_access_token,
|
|
};
|
|
use serde_json::Value;
|
|
use std::time::Duration;
|
|
use time::OffsetDateTime;
|
|
use tower::ServiceExt;
|
|
|
|
use crate::{app::build_router, config::AppConfig, state::AppState};
|
|
|
|
#[test]
|
|
fn profile_wallet_ledger_source_type_formats_backend_values() {
|
|
assert_eq!(
|
|
format_profile_wallet_ledger_source_type(
|
|
RuntimeProfileWalletLedgerSourceType::NewUserRegistrationReward
|
|
),
|
|
shared_contracts::runtime::PROFILE_WALLET_LEDGER_SOURCE_TYPE_NEW_USER_REGISTRATION_REWARD
|
|
);
|
|
assert_eq!(
|
|
format_profile_wallet_ledger_source_type(
|
|
RuntimeProfileWalletLedgerSourceType::AssetOperationConsume
|
|
),
|
|
shared_contracts::runtime::PROFILE_WALLET_LEDGER_SOURCE_TYPE_ASSET_OPERATION_CONSUME
|
|
);
|
|
assert_eq!(
|
|
format_profile_wallet_ledger_source_type(
|
|
RuntimeProfileWalletLedgerSourceType::AssetOperationRefund
|
|
),
|
|
shared_contracts::runtime::PROFILE_WALLET_LEDGER_SOURCE_TYPE_ASSET_OPERATION_REFUND
|
|
);
|
|
assert_eq!(
|
|
format_profile_wallet_ledger_source_type(
|
|
RuntimeProfileWalletLedgerSourceType::PuzzleAuthorIncentiveClaim
|
|
),
|
|
shared_contracts::runtime::PROFILE_WALLET_LEDGER_SOURCE_TYPE_PUZZLE_AUTHOR_INCENTIVE_CLAIM
|
|
);
|
|
assert_eq!(
|
|
format_profile_wallet_ledger_source_type(
|
|
RuntimeProfileWalletLedgerSourceType::DailyTaskReward
|
|
),
|
|
shared_contracts::runtime::PROFILE_WALLET_LEDGER_SOURCE_TYPE_DAILY_TASK_REWARD
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_dashboard_requires_authentication() {
|
|
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
|
|
|
let response = app
|
|
.clone()
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("GET")
|
|
.uri("/api/profile/dashboard")
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
|
|
|
let confirm_response = app
|
|
.clone()
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/recharge/orders/rcgtest001/wechat/confirm")
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(confirm_response.status(), StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_wallet_ledger_requires_authentication() {
|
|
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("GET")
|
|
.uri("/api/profile/wallet-ledger")
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_tasks_require_authentication() {
|
|
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
|
|
|
let list_response = app
|
|
.clone()
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("GET")
|
|
.uri("/api/profile/tasks")
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
let claim_response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/tasks/daily_login/claim")
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(list_response.status(), StatusCode::UNAUTHORIZED);
|
|
assert_eq!(claim_response.status(), StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_play_stats_requires_authentication() {
|
|
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("GET")
|
|
.uri("/api/profile/play-stats")
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_recharge_center_requires_authentication() {
|
|
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("GET")
|
|
.uri("/api/profile/recharge-center")
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_recharge_order_requires_authentication() {
|
|
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/recharge/orders")
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(r#"{"productId":"points_60"}"#))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_recharge_order_rejects_missing_payment_channel_before_spacetime() {
|
|
let state = seed_authenticated_state().await;
|
|
let token = issue_access_token(&state);
|
|
let app = build_router(state);
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/recharge/orders")
|
|
.header("authorization", format!("Bearer {token}"))
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(r#"{"productId":"points_60"}"#))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
|
|
let body = response
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.expect("body should collect")
|
|
.to_bytes();
|
|
let payload: Value =
|
|
serde_json::from_slice(&body).expect("response body should be valid json");
|
|
assert_eq!(payload["error"]["message"], "充值支付渠道不能为空");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_recharge_order_rejects_unknown_payment_channel_before_spacetime() {
|
|
let state = seed_authenticated_state().await;
|
|
let token = issue_access_token(&state);
|
|
let app = build_router(state);
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/recharge/orders")
|
|
.header("authorization", format!("Bearer {token}"))
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(
|
|
r#"{"productId":"points_60","paymentChannel":"card"}"#,
|
|
))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
|
|
let body = response
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.expect("body should collect")
|
|
.to_bytes();
|
|
let payload: Value =
|
|
serde_json::from_slice(&body).expect("response body should be valid json");
|
|
assert_eq!(payload["error"]["message"], "充值支付渠道无效");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_recharge_order_rejects_mock_when_pay_provider_is_real() {
|
|
let state = seed_authenticated_state_with_config(AppConfig {
|
|
wechat_pay_provider: "real".to_string(),
|
|
spacetime_procedure_timeout: Duration::from_secs(1),
|
|
..AppConfig::default()
|
|
})
|
|
.await;
|
|
let token = issue_access_token(&state);
|
|
let app = build_router(state);
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/recharge/orders")
|
|
.header("authorization", format!("Bearer {token}"))
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(
|
|
r#"{"productId":"points_60","paymentChannel":"mock"}"#,
|
|
))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
|
|
let body = response
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.expect("body should collect")
|
|
.to_bytes();
|
|
let payload: Value =
|
|
serde_json::from_slice(&body).expect("response body should be valid json");
|
|
assert_eq!(
|
|
payload["error"]["message"],
|
|
"生产充值不允许使用 mock 支付渠道"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_recharge_order_rejects_non_wechat_device_before_spacetime() {
|
|
let state = seed_authenticated_state_with_config(AppConfig {
|
|
wechat_pay_enabled: true,
|
|
wechat_pay_provider: "mock".to_string(),
|
|
spacetime_procedure_timeout: Duration::from_secs(1),
|
|
..AppConfig::default()
|
|
})
|
|
.await;
|
|
let token = issue_access_token(&state);
|
|
let app = build_router(state);
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/recharge/orders")
|
|
.header("authorization", format!("Bearer {token}"))
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(
|
|
r#"{"productId":"points_60","paymentChannel":"wechat_h5"}"#,
|
|
))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::FORBIDDEN);
|
|
let body = response
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.expect("body should collect")
|
|
.to_bytes();
|
|
let payload: Value =
|
|
serde_json::from_slice(&body).expect("response body should be valid json");
|
|
assert_eq!(
|
|
payload["error"]["message"],
|
|
"当前登录设备不支持充值，请在微信环境内登录后重试"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_recharge_order_rejects_mismatched_wechat_channel_before_spacetime() {
|
|
let state = seed_authenticated_state_with_config(AppConfig {
|
|
wechat_pay_enabled: true,
|
|
wechat_pay_provider: "mock".to_string(),
|
|
spacetime_procedure_timeout: Duration::from_secs(1),
|
|
..AppConfig::default()
|
|
})
|
|
.await;
|
|
let token = issue_wechat_h5_access_token(&state, "ios", "sess_runtime_profile_mobile_h5");
|
|
let app = build_router(state);
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/recharge/orders")
|
|
.header("authorization", format!("Bearer {token}"))
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(
|
|
r#"{"productId":"points_60","paymentChannel":"wechat_native"}"#,
|
|
))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::FORBIDDEN);
|
|
let body = response
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.expect("body should collect")
|
|
.to_bytes();
|
|
let payload: Value =
|
|
serde_json::from_slice(&body).expect("response body should be valid json");
|
|
assert_eq!(
|
|
payload["error"]["message"],
|
|
"当前登录设备不支持充值，请在微信环境内登录后重试"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_recharge_order_allows_desktop_wechat_native_channel_before_provider_check() {
|
|
let state = seed_authenticated_state_with_config(AppConfig {
|
|
wechat_pay_enabled: true,
|
|
wechat_pay_provider: "mock".to_string(),
|
|
spacetime_procedure_timeout: Duration::from_secs(1),
|
|
..AppConfig::default()
|
|
})
|
|
.await;
|
|
let token =
|
|
issue_wechat_h5_access_token(&state, "windows", "sess_runtime_profile_desktop_wechat");
|
|
let app = build_router(state);
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/recharge/orders")
|
|
.header("authorization", format!("Bearer {token}"))
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(
|
|
r#"{"productId":"points_60","paymentChannel":"wechat_native"}"#,
|
|
))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
|
|
let body = response
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.expect("body should collect")
|
|
.to_bytes();
|
|
let payload: Value =
|
|
serde_json::from_slice(&body).expect("response body should be valid json");
|
|
assert_eq!(
|
|
payload["error"]["message"],
|
|
"真实微信支付渠道不能使用 mock 支付配置"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_recharge_order_rejects_real_wechat_channel_when_pay_provider_is_mock() {
|
|
let state = seed_authenticated_state_with_config(AppConfig {
|
|
wechat_pay_enabled: true,
|
|
wechat_pay_provider: "mock".to_string(),
|
|
spacetime_procedure_timeout: Duration::from_secs(1),
|
|
..AppConfig::default()
|
|
})
|
|
.await;
|
|
let token = issue_wechat_h5_access_token(&state, "ios", "sess_runtime_profile_wechat_h5");
|
|
let app = build_router(state);
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/recharge/orders")
|
|
.header("authorization", format!("Bearer {token}"))
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(
|
|
r#"{"productId":"points_60","paymentChannel":"wechat_h5"}"#,
|
|
))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
|
|
let body = response
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.expect("body should collect")
|
|
.to_bytes();
|
|
let payload: Value =
|
|
serde_json::from_slice(&body).expect("response body should be valid json");
|
|
assert_eq!(
|
|
payload["error"]["message"],
|
|
"真实微信支付渠道不能使用 mock 支付配置"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn wechat_virtual_pay_params_use_goods_mode_for_membership_products() {
|
|
let state = seed_authenticated_state_with_config(AppConfig {
|
|
wechat_mini_program_virtual_payment_offer_id: Some("offer-1".to_string()),
|
|
wechat_mini_program_virtual_payment_app_key: Some("app-key-1".to_string()),
|
|
wechat_mini_program_virtual_payment_env: 0,
|
|
..fast_spacetime_timeout_config()
|
|
})
|
|
.await;
|
|
let wechat_login = state
|
|
.wechat_auth_service()
|
|
.resolve_login(ResolveWechatLoginInput {
|
|
profile: WechatIdentityProfile {
|
|
provider_uid: "openid-user-00000001".to_string(),
|
|
provider_union_id: Some("union-user-00000001".to_string()),
|
|
display_name: Some("资料页用户".to_string()),
|
|
avatar_url: None,
|
|
session_key: Some("session-key-1".to_string()),
|
|
},
|
|
})
|
|
.await
|
|
.expect("wechat identity should seed");
|
|
let user_id = wechat_login.user.id;
|
|
let order = RuntimeProfileRechargeOrderRecord {
|
|
order_id: "memberorder01".to_string(),
|
|
user_id: user_id.clone(),
|
|
product_id: "member_month".to_string(),
|
|
product_title: "月卡".to_string(),
|
|
kind: RuntimeProfileRechargeProductKind::Membership,
|
|
amount_cents: 2800,
|
|
status: RuntimeProfileRechargeOrderStatus::Pending,
|
|
payment_channel: PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM_VIRTUAL
|
|
.to_string(),
|
|
paid_at: None,
|
|
paid_at_micros: None,
|
|
provider_transaction_id: None,
|
|
created_at: "2026-05-26T10:00:00Z".to_string(),
|
|
created_at_micros: 1_779_756_000_000_000,
|
|
points_delta: 0,
|
|
membership_expires_at: None,
|
|
membership_expires_at_micros: None,
|
|
};
|
|
|
|
let center = RuntimeProfileRechargeCenterRecord {
|
|
user_id: user_id.clone(),
|
|
wallet_balance: 0,
|
|
membership: RuntimeProfileMembershipRecord {
|
|
user_id: user_id.clone(),
|
|
status: RuntimeProfileMembershipStatus::Normal,
|
|
tier: RuntimeProfileMembershipTier::Normal,
|
|
started_at: None,
|
|
started_at_micros: None,
|
|
expires_at: None,
|
|
expires_at_micros: None,
|
|
updated_at: None,
|
|
updated_at_micros: None,
|
|
},
|
|
point_products: vec![],
|
|
membership_products: vec![RuntimeProfileRechargeProductRecord {
|
|
product_id: "member_month".to_string(),
|
|
title: "月卡".to_string(),
|
|
price_cents: 2800,
|
|
kind: RuntimeProfileRechargeProductKind::Membership,
|
|
points_amount: 0,
|
|
bonus_points: 0,
|
|
duration_days: 30,
|
|
badge_label: String::new(),
|
|
description: "30天会员".to_string(),
|
|
tier: RuntimeProfileMembershipTier::Month,
|
|
}],
|
|
benefits: vec![],
|
|
latest_order: None,
|
|
has_points_recharged: false,
|
|
};
|
|
|
|
let params =
|
|
build_wechat_virtual_pay_params(&state, ¢er, &order, "openid-user-00000001")
|
|
.expect("membership virtual pay params should build");
|
|
let sign_data: Value =
|
|
serde_json::from_str(¶ms.sign_data).expect("sign data should be valid json");
|
|
let attach: Value = serde_json::from_str(
|
|
sign_data["attach"]
|
|
.as_str()
|
|
.expect("attach should be string json"),
|
|
)
|
|
.expect("attach should decode");
|
|
|
|
assert_eq!(params.mode, "short_series_goods");
|
|
assert_eq!(sign_data["buyQuantity"], 1);
|
|
assert_eq!(sign_data["offerId"], "offer-1");
|
|
assert_eq!(sign_data["productId"], "member_month");
|
|
assert_eq!(sign_data["goodsPrice"], 2800);
|
|
assert_eq!(sign_data["outTradeNo"], "memberorder01");
|
|
assert_eq!(attach["paymentChannel"], "wechat_mp_virtual");
|
|
assert!(!params.pay_sig.is_empty());
|
|
assert!(!params.signature.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn wechat_virtual_pay_params_use_coin_quantity_for_points_products() {
|
|
let state = seed_authenticated_state_with_config(AppConfig {
|
|
wechat_mini_program_virtual_payment_offer_id: Some("offer-1".to_string()),
|
|
wechat_mini_program_virtual_payment_app_key: Some("app-key-1".to_string()),
|
|
wechat_mini_program_virtual_payment_env: 0,
|
|
..fast_spacetime_timeout_config()
|
|
})
|
|
.await;
|
|
let wechat_login = state
|
|
.wechat_auth_service()
|
|
.resolve_login(ResolveWechatLoginInput {
|
|
profile: WechatIdentityProfile {
|
|
provider_uid: "openid-user-points-60".to_string(),
|
|
provider_union_id: Some("union-user-points-60".to_string()),
|
|
display_name: Some("资料页用户".to_string()),
|
|
avatar_url: None,
|
|
session_key: Some("session-key-points-60".to_string()),
|
|
},
|
|
})
|
|
.await
|
|
.expect("wechat identity should seed");
|
|
let user_id = wechat_login.user.id.clone();
|
|
let order = RuntimeProfileRechargeOrderRecord {
|
|
order_id: "pointsorder60".to_string(),
|
|
user_id: user_id.clone(),
|
|
product_id: "points_60".to_string(),
|
|
product_title: "60泥点".to_string(),
|
|
kind: RuntimeProfileRechargeProductKind::Points,
|
|
amount_cents: 600,
|
|
status: RuntimeProfileRechargeOrderStatus::Pending,
|
|
payment_channel: PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM_VIRTUAL
|
|
.to_string(),
|
|
paid_at: None,
|
|
paid_at_micros: None,
|
|
provider_transaction_id: None,
|
|
created_at: "2026-05-30T10:00:00Z".to_string(),
|
|
created_at_micros: 1_780_000_000_000_000,
|
|
points_delta: 0,
|
|
membership_expires_at: None,
|
|
membership_expires_at_micros: None,
|
|
};
|
|
|
|
let center = RuntimeProfileRechargeCenterRecord {
|
|
user_id: user_id.clone(),
|
|
wallet_balance: 0,
|
|
membership: RuntimeProfileMembershipRecord {
|
|
user_id: user_id.clone(),
|
|
status: RuntimeProfileMembershipStatus::Normal,
|
|
tier: RuntimeProfileMembershipTier::Normal,
|
|
started_at: None,
|
|
started_at_micros: None,
|
|
expires_at: None,
|
|
expires_at_micros: None,
|
|
updated_at: None,
|
|
updated_at_micros: None,
|
|
},
|
|
point_products: vec![RuntimeProfileRechargeProductRecord {
|
|
product_id: "points_60".to_string(),
|
|
title: "60泥点".to_string(),
|
|
price_cents: 600,
|
|
kind: RuntimeProfileRechargeProductKind::Points,
|
|
points_amount: 60,
|
|
bonus_points: 60,
|
|
duration_days: 0,
|
|
badge_label: "首充双倍".to_string(),
|
|
description: "60+60泥点".to_string(),
|
|
tier: RuntimeProfileMembershipTier::Normal,
|
|
}],
|
|
membership_products: vec![],
|
|
benefits: vec![],
|
|
latest_order: None,
|
|
has_points_recharged: true,
|
|
};
|
|
|
|
let params =
|
|
build_wechat_virtual_pay_params(&state, ¢er, &order, "openid-user-points-60")
|
|
.expect("points virtual pay params should build");
|
|
let sign_data: Value =
|
|
serde_json::from_str(¶ms.sign_data).expect("sign data should be valid json");
|
|
let attach: Value = serde_json::from_str(
|
|
sign_data["attach"]
|
|
.as_str()
|
|
.expect("attach should be string json"),
|
|
)
|
|
.expect("attach should decode");
|
|
|
|
assert_eq!(params.mode, "short_series_coin");
|
|
assert_eq!(sign_data["buyQuantity"], 60);
|
|
assert_eq!(sign_data["offerId"], "offer-1");
|
|
assert_eq!(sign_data["outTradeNo"], "pointsorder60");
|
|
assert_eq!(attach["paymentChannel"], "wechat_mp_virtual");
|
|
assert!(!params.pay_sig.is_empty());
|
|
assert!(!params.signature.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn wechat_virtual_pay_params_accept_admin_membership_product_ids() {
|
|
let state = seed_authenticated_state_with_config(AppConfig {
|
|
wechat_mini_program_virtual_payment_offer_id: Some("offer-1".to_string()),
|
|
wechat_mini_program_virtual_payment_app_key: Some("app-key-1".to_string()),
|
|
wechat_mini_program_virtual_payment_env: 0,
|
|
..fast_spacetime_timeout_config()
|
|
})
|
|
.await;
|
|
let wechat_login = state
|
|
.wechat_auth_service()
|
|
.resolve_login(ResolveWechatLoginInput {
|
|
profile: WechatIdentityProfile {
|
|
provider_uid: "openid-user-item01".to_string(),
|
|
provider_union_id: Some("union-user-item01".to_string()),
|
|
display_name: Some("资料页用户".to_string()),
|
|
avatar_url: None,
|
|
session_key: Some("session-key-item01".to_string()),
|
|
},
|
|
})
|
|
.await
|
|
.expect("wechat identity should seed");
|
|
let user_id = wechat_login.user.id.clone();
|
|
let order = RuntimeProfileRechargeOrderRecord {
|
|
order_id: "item01order01".to_string(),
|
|
user_id: user_id.clone(),
|
|
product_id: "item01".to_string(),
|
|
product_title: "测试道具".to_string(),
|
|
kind: RuntimeProfileRechargeProductKind::Membership,
|
|
amount_cents: 100,
|
|
status: RuntimeProfileRechargeOrderStatus::Pending,
|
|
payment_channel: PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM_VIRTUAL
|
|
.to_string(),
|
|
paid_at: None,
|
|
paid_at_micros: None,
|
|
provider_transaction_id: None,
|
|
created_at: "2026-05-27T10:00:00Z".to_string(),
|
|
created_at_micros: 1_779_842_400_000_000,
|
|
points_delta: 0,
|
|
membership_expires_at: None,
|
|
membership_expires_at_micros: None,
|
|
};
|
|
|
|
let center = RuntimeProfileRechargeCenterRecord {
|
|
user_id: user_id.clone(),
|
|
wallet_balance: 0,
|
|
membership: RuntimeProfileMembershipRecord {
|
|
user_id: user_id.clone(),
|
|
status: RuntimeProfileMembershipStatus::Normal,
|
|
tier: RuntimeProfileMembershipTier::Normal,
|
|
started_at: None,
|
|
started_at_micros: None,
|
|
expires_at: None,
|
|
expires_at_micros: None,
|
|
updated_at: None,
|
|
updated_at_micros: None,
|
|
},
|
|
point_products: vec![],
|
|
membership_products: vec![RuntimeProfileRechargeProductRecord {
|
|
product_id: "item01".to_string(),
|
|
title: "测试道具".to_string(),
|
|
price_cents: 100,
|
|
kind: RuntimeProfileRechargeProductKind::Membership,
|
|
points_amount: 0,
|
|
bonus_points: 0,
|
|
duration_days: 30,
|
|
badge_label: String::new(),
|
|
description: "30天会员".to_string(),
|
|
tier: RuntimeProfileMembershipTier::Month,
|
|
}],
|
|
benefits: vec![],
|
|
latest_order: None,
|
|
has_points_recharged: false,
|
|
};
|
|
|
|
let params = build_wechat_virtual_pay_params(&state, ¢er, &order, "openid-user-item01")
|
|
.expect("custom membership virtual pay params should build");
|
|
let sign_data: Value =
|
|
serde_json::from_str(¶ms.sign_data).expect("sign data should be valid json");
|
|
|
|
assert_eq!(params.mode, "short_series_goods");
|
|
assert_eq!(sign_data["productId"], "item01");
|
|
assert_eq!(sign_data["goodsPrice"], 100);
|
|
assert_eq!(sign_data["outTradeNo"], "item01order01");
|
|
}
|
|
|
|
#[test]
|
|
fn wechat_virtual_payment_signatures_match_official_examples() {
|
|
let post_body = r#"{"openid": "xxx", "user_ip": "127.0.0.1", "env": 0}"#;
|
|
|
|
let pay_sig = calc_wechat_virtual_payment_pay_signature_with_key("12345", post_body)
|
|
.expect("pay signature should build");
|
|
let signature = calc_wechat_virtual_payment_user_signature_with_key(
|
|
"9hAb/NEYUlkaMBEsmFgzig==",
|
|
post_body,
|
|
)
|
|
.expect("user signature should build");
|
|
|
|
assert_eq!(
|
|
pay_sig,
|
|
"a1ab2651b927b6a766152cf864033417b85c1448fc3c6e1bedbbd7f49416e92f"
|
|
);
|
|
assert_eq!(
|
|
signature,
|
|
"089d9e8dc5d308977360c4b79ec600a93d736802802a807d634192328032f6c7"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn wechat_virtual_payment_sandbox_requires_sandbox_app_key() {
|
|
let state = seed_authenticated_state_with_config(AppConfig {
|
|
wechat_mini_program_virtual_payment_offer_id: Some("offer-1".to_string()),
|
|
wechat_mini_program_virtual_payment_app_key: Some("app-key-1".to_string()),
|
|
wechat_mini_program_virtual_payment_sandbox_app_key: None,
|
|
wechat_mini_program_virtual_payment_env: 1,
|
|
..fast_spacetime_timeout_config()
|
|
})
|
|
.await;
|
|
let wechat_login = state
|
|
.wechat_auth_service()
|
|
.resolve_login(ResolveWechatLoginInput {
|
|
profile: WechatIdentityProfile {
|
|
provider_uid: "openid-sandbox-1".to_string(),
|
|
provider_union_id: Some("union-sandbox-1".to_string()),
|
|
display_name: Some("资料页用户".to_string()),
|
|
avatar_url: None,
|
|
session_key: Some("session-key-sandbox-1".to_string()),
|
|
},
|
|
})
|
|
.await
|
|
.expect("wechat identity should seed");
|
|
let user_id = wechat_login.user.id.clone();
|
|
let order = RuntimeProfileRechargeOrderRecord {
|
|
order_id: "sandboxorder01".to_string(),
|
|
user_id: user_id.clone(),
|
|
product_id: "points_60".to_string(),
|
|
product_title: "60泥点".to_string(),
|
|
kind: RuntimeProfileRechargeProductKind::Points,
|
|
amount_cents: 600,
|
|
status: RuntimeProfileRechargeOrderStatus::Pending,
|
|
payment_channel: PROFILE_RECHARGE_PAYMENT_CHANNEL_WECHAT_MINI_PROGRAM_VIRTUAL
|
|
.to_string(),
|
|
paid_at: None,
|
|
paid_at_micros: None,
|
|
provider_transaction_id: None,
|
|
created_at: "2026-05-30T10:00:00Z".to_string(),
|
|
created_at_micros: 1_780_000_000_000_000,
|
|
points_delta: 0,
|
|
membership_expires_at: None,
|
|
membership_expires_at_micros: None,
|
|
};
|
|
|
|
let center = RuntimeProfileRechargeCenterRecord {
|
|
user_id: user_id.clone(),
|
|
wallet_balance: 0,
|
|
membership: RuntimeProfileMembershipRecord {
|
|
user_id: user_id.clone(),
|
|
status: RuntimeProfileMembershipStatus::Normal,
|
|
tier: RuntimeProfileMembershipTier::Normal,
|
|
started_at: None,
|
|
started_at_micros: None,
|
|
expires_at: None,
|
|
expires_at_micros: None,
|
|
updated_at: None,
|
|
updated_at_micros: None,
|
|
},
|
|
point_products: vec![RuntimeProfileRechargeProductRecord {
|
|
product_id: "points_60".to_string(),
|
|
title: "60泥点".to_string(),
|
|
price_cents: 600,
|
|
kind: RuntimeProfileRechargeProductKind::Points,
|
|
points_amount: 60,
|
|
bonus_points: 60,
|
|
duration_days: 0,
|
|
badge_label: "首充双倍".to_string(),
|
|
description: "60+60泥点".to_string(),
|
|
tier: RuntimeProfileMembershipTier::Normal,
|
|
}],
|
|
membership_products: vec![],
|
|
benefits: vec![],
|
|
latest_order: None,
|
|
has_points_recharged: false,
|
|
};
|
|
|
|
let error = build_wechat_virtual_pay_params(&state, ¢er, &order, "openid-sandbox-1")
|
|
.expect_err("sandbox pay params should reject missing sandbox app key");
|
|
assert!(
|
|
error.to_string().contains("沙箱 AppKey 未配置"),
|
|
"unexpected error: {error}"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_feedback_requires_authentication() {
|
|
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/feedback")
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(
|
|
r#"{"description":"反馈页面上传图片后没有显示预览"}"#,
|
|
))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_referral_invite_center_requires_authentication() {
|
|
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("GET")
|
|
.uri("/api/profile/referrals/invite-center")
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_referral_redeem_code_requires_authentication() {
|
|
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/referrals/redeem-code")
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(r#"{"inviteCode":"SY12345678"}"#))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn profile_referral_redeem_code_calls_spacetime_for_authenticated_user() {
|
|
let state = seed_authenticated_state().await;
|
|
let token = issue_access_token(&state);
|
|
let app = build_router(state);
|
|
|
|
let response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/api/profile/referrals/redeem-code")
|
|
.header("authorization", format!("Bearer {token}"))
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(r#"{"inviteCode":"SY12345678"}"#))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
|
|
let body = response
|
|
.into_body()
|
|
.collect()
|
|
.await
|
|
.expect("body should collect")
|
|
.to_bytes();
|
|
let payload: Value =
|
|
serde_json::from_slice(&body).expect("response body should be valid json");
|
|
assert_eq!(
|
|
payload["error"]["details"]["provider"],
|
|
Value::String("spacetimedb".to_string())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn admin_invite_code_metadata_accepts_only_json_object() {
|
|
assert_eq!(
|
|
normalize_admin_invite_code_metadata(None).expect("empty metadata should default"),
|
|
"{}"
|
|
);
|
|
assert_eq!(
|
|
normalize_admin_invite_code_metadata(Some(serde_json::json!({
|
|
"channel": "spring",
|
|
"source": "banner"
|
|
})))
|
|
.expect("object metadata should serialize"),
|
|
r#"{"channel":"spring","source":"banner"}"#
|
|
);
|
|
|
|
let error = normalize_admin_invite_code_metadata(Some(serde_json::json!("spring")))
|
|
.expect_err("non-object metadata should reject");
|
|
assert_eq!(error.message(), "邀请码 metadata 必须是 JSON 对象");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn runtime_profile_legacy_routes_are_not_mounted() {
|
|
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
|
|
|
for uri in [
|
|
"/api/runtime/profile/dashboard",
|
|
"/api/runtime/profile/wallet-ledger",
|
|
"/api/runtime/profile/recharge-center",
|
|
"/api/runtime/profile/recharge/orders",
|
|
"/api/runtime/profile/feedback",
|
|
"/api/runtime/profile/referrals/invite-center",
|
|
"/api/runtime/profile/referrals/redeem-code",
|
|
"/api/runtime/profile/redeem-codes/redeem",
|
|
"/api/runtime/profile/play-stats",
|
|
"/api/runtime/profile/save-archives",
|
|
"/api/runtime/profile/save-archives/world-1",
|
|
"/api/runtime/profile/browse-history",
|
|
] {
|
|
let response = app
|
|
.clone()
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("GET")
|
|
.uri(uri)
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::NOT_FOUND, "{uri}");
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn admin_profile_task_routes_require_admin_authentication() {
|
|
let app =
|
|
build_router(AppState::new(admin_enabled_test_config()).expect("state should build"));
|
|
|
|
let list_response = app
|
|
.clone()
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("GET")
|
|
.uri("/admin/api/profile/tasks")
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
let upsert_response = app
|
|
.clone()
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/admin/api/profile/tasks")
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(r#"{"taskId":"daily_login"}"#))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
let disable_response = app
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("POST")
|
|
.uri("/admin/api/profile/tasks/disable")
|
|
.header("content-type", "application/json")
|
|
.body(Body::from(r#"{"taskId":"daily_login"}"#))
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(list_response.status(), StatusCode::UNAUTHORIZED);
|
|
assert_eq!(upsert_response.status(), StatusCode::UNAUTHORIZED);
|
|
assert_eq!(disable_response.status(), StatusCode::UNAUTHORIZED);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn admin_profile_code_list_routes_require_admin_authentication() {
|
|
let app =
|
|
build_router(AppState::new(admin_enabled_test_config()).expect("state should build"));
|
|
|
|
for uri in [
|
|
"/admin/api/profile/redeem-codes",
|
|
"/admin/api/profile/invite-codes",
|
|
"/admin/api/profile/recharge-products",
|
|
] {
|
|
let response = app
|
|
.clone()
|
|
.oneshot(
|
|
Request::builder()
|
|
.method("GET")
|
|
.uri(uri)
|
|
.body(Body::empty())
|
|
.expect("request should build"),
|
|
)
|
|
.await
|
|
.expect("request should succeed");
|
|
|
|
assert_eq!(response.status(), StatusCode::UNAUTHORIZED, "{uri}");
|
|
}
|
|
}
|
|
|
|
async fn seed_authenticated_state() -> AppState {
|
|
seed_authenticated_state_with_config(fast_spacetime_timeout_config()).await
|
|
}
|
|
|
|
async fn seed_authenticated_state_with_config(config: AppConfig) -> AppState {
|
|
let state = AppState::new(config).expect("state should build");
|
|
state
|
|
.seed_test_phone_user_with_password("13800138104", "secret123")
|
|
.await
|
|
.id;
|
|
state
|
|
}
|
|
|
|
fn fast_spacetime_timeout_config() -> AppConfig {
|
|
AppConfig {
|
|
spacetime_procedure_timeout: Duration::from_secs(1),
|
|
..AppConfig::default()
|
|
}
|
|
}
|
|
|
|
fn admin_enabled_test_config() -> AppConfig {
|
|
AppConfig {
|
|
admin_username: Some("root".to_string()),
|
|
admin_password: Some("secret123".to_string()),
|
|
..AppConfig::default()
|
|
}
|
|
}
|
|
|
|
fn issue_access_token(state: &AppState) -> String {
|
|
let user_id = test_authenticated_user_id(state);
|
|
let claims = AccessTokenClaims::from_input(
|
|
AccessTokenClaimsInput {
|
|
user_id: user_id.clone(),
|
|
session_id: state
|
|
.seed_test_refresh_session_for_user_id(&user_id, "sess_runtime_profile"),
|
|
provider: AuthProvider::Password,
|
|
roles: vec!["user".to_string()],
|
|
token_version: 2,
|
|
phone_verified: true,
|
|
binding_status: BindingStatus::Active,
|
|
display_name: Some("资料页用户".to_string()),
|
|
},
|
|
state.auth_jwt_config(),
|
|
OffsetDateTime::now_utc(),
|
|
)
|
|
.expect("claims should build");
|
|
|
|
sign_access_token(&claims, state.auth_jwt_config()).expect("token should sign")
|
|
}
|
|
|
|
fn issue_wechat_h5_access_token(
|
|
state: &AppState,
|
|
client_platform: &str,
|
|
session_id: &str,
|
|
) -> String {
|
|
let user_id = test_authenticated_user_id(state);
|
|
let claims = AccessTokenClaims::from_input_with_device(
|
|
AccessTokenClaimsInput {
|
|
user_id: user_id.clone(),
|
|
session_id: state.seed_test_refresh_session_for_user_id(&user_id, session_id),
|
|
provider: AuthProvider::Wechat,
|
|
roles: vec!["user".to_string()],
|
|
token_version: 2,
|
|
phone_verified: true,
|
|
binding_status: BindingStatus::Active,
|
|
display_name: Some("微信资料页用户".to_string()),
|
|
},
|
|
Some(platform_auth::AccessTokenDeviceInfo {
|
|
client_type: "wechat_h5".to_string(),
|
|
client_runtime: "wechat_embedded_browser".to_string(),
|
|
client_platform: client_platform.to_string(),
|
|
}),
|
|
state.auth_jwt_config(),
|
|
OffsetDateTime::now_utc(),
|
|
)
|
|
.expect("claims should build");
|
|
|
|
sign_access_token(&claims, state.auth_jwt_config()).expect("token should sign")
|
|
}
|
|
|
|
fn test_authenticated_user_id(state: &AppState) -> String {
|
|
state
|
|
.auth_user_service()
|
|
.get_user_by_public_user_code("SY-00000001")
|
|
.expect("test user lookup should succeed")
|
|
.expect("seeded test user should exist")
|
|
.id
|
|
}
|
|
}
|