328 lines
9.9 KiB
TypeScript
328 lines
9.9 KiB
TypeScript
import { apiClient } from './client'
|
|
|
|
export type ChargeMode = '赠送' | '收费'
|
|
|
|
export type QuantityKey = string
|
|
|
|
export type ScreenshotKey = string
|
|
|
|
export type SkinCategoryKey = string
|
|
|
|
export interface PublishOptionGroup {
|
|
key: SkinCategoryKey | string
|
|
title: string
|
|
options: string[]
|
|
}
|
|
|
|
export interface PublishQuantityItem {
|
|
key: QuantityKey
|
|
label: string
|
|
price: string
|
|
placeholder?: string
|
|
}
|
|
|
|
export interface PublishScreenshotSlot {
|
|
key: ScreenshotKey
|
|
label: string
|
|
required: boolean
|
|
hint: string
|
|
}
|
|
|
|
export interface PublishPriceConfig {
|
|
deposit_placeholder: string
|
|
price_placeholder: string
|
|
ratio_description: string
|
|
}
|
|
|
|
export interface PublishInsuranceBaseRatio {
|
|
insurance: string
|
|
ratio: number
|
|
}
|
|
|
|
export interface PublishRatioConfigItem {
|
|
key: string
|
|
label: string
|
|
kind: string
|
|
group_key?: string
|
|
missing_penalty: number
|
|
}
|
|
|
|
export interface PublishCoinCorrection {
|
|
threshold_m: number
|
|
correction: number
|
|
}
|
|
|
|
export interface PublishSaleFixedMarkupRule {
|
|
min_m: number
|
|
max_m: number
|
|
markup_amount: number
|
|
}
|
|
|
|
export interface PublishSaleRatioAdjustmentRule {
|
|
min_m: number
|
|
max_m: number
|
|
ratio_subtract: number
|
|
}
|
|
|
|
export interface PublishRatioConfig {
|
|
insurance_base_ratios: PublishInsuranceBaseRatio[]
|
|
config_items: PublishRatioConfigItem[]
|
|
coin_corrections: PublishCoinCorrection[]
|
|
}
|
|
|
|
export interface PublishSalePriceConfig {
|
|
fixed_markup_rules: PublishSaleFixedMarkupRule[]
|
|
ratio_adjustment_rules: PublishSaleRatioAdjustmentRule[]
|
|
}
|
|
|
|
export interface ListingPublishOptions {
|
|
server_options: string[]
|
|
face_options: string[]
|
|
rank_options: string[]
|
|
insurance_options: string[]
|
|
level_options: string[]
|
|
login_method_options: string[]
|
|
region_options: string[]
|
|
skin_groups: PublishOptionGroup[]
|
|
quantity_items: PublishQuantityItem[]
|
|
screenshot_slots: PublishScreenshotSlot[]
|
|
ban_record_options: string[]
|
|
ban_evidence_options: string[]
|
|
fire_level_min: number
|
|
price_config: PublishPriceConfig
|
|
ratio_config: PublishRatioConfig
|
|
sale_price_config: PublishSalePriceConfig
|
|
}
|
|
|
|
interface ApiResponse<T> {
|
|
code: string
|
|
message: string
|
|
data: T
|
|
}
|
|
|
|
export const emptyListingPublishOptions: ListingPublishOptions = {
|
|
server_options: [],
|
|
face_options: [],
|
|
rank_options: [],
|
|
insurance_options: [],
|
|
level_options: [],
|
|
login_method_options: [],
|
|
region_options: [],
|
|
skin_groups: [],
|
|
quantity_items: [],
|
|
screenshot_slots: [],
|
|
ban_record_options: [],
|
|
ban_evidence_options: [],
|
|
fire_level_min: 38,
|
|
price_config: {
|
|
deposit_placeholder: '',
|
|
price_placeholder: '',
|
|
ratio_description: '',
|
|
},
|
|
ratio_config: {
|
|
insurance_base_ratios: [],
|
|
config_items: [],
|
|
coin_corrections: [],
|
|
},
|
|
sale_price_config: {
|
|
fixed_markup_rules: [],
|
|
ratio_adjustment_rules: [],
|
|
},
|
|
}
|
|
|
|
export async function fetchListingPublishOptions() {
|
|
const { data } = await apiClient.get<ApiResponse<ListingPublishOptions>>('/listing-publish-options')
|
|
return mergeListingPublishOptions(data.data)
|
|
}
|
|
|
|
export function mergeListingPublishOptions(options?: Partial<ListingPublishOptions>): ListingPublishOptions {
|
|
return {
|
|
server_options: normalizeStringList(options?.server_options),
|
|
face_options: normalizeStringList(options?.face_options),
|
|
rank_options: normalizeStringList(options?.rank_options),
|
|
insurance_options: normalizeStringList(options?.insurance_options),
|
|
level_options: normalizeStringList(options?.level_options),
|
|
login_method_options: normalizeStringList(options?.login_method_options),
|
|
region_options: normalizeStringList(options?.region_options),
|
|
skin_groups: normalizeOptionGroups(options?.skin_groups),
|
|
quantity_items: normalizeQuantityItems(options?.quantity_items),
|
|
screenshot_slots: normalizeScreenshotSlots(options?.screenshot_slots),
|
|
ban_record_options: normalizeStringList(options?.ban_record_options),
|
|
ban_evidence_options: normalizeStringList(options?.ban_evidence_options),
|
|
fire_level_min: readPositiveInteger(options?.fire_level_min, 38),
|
|
price_config: normalizePriceConfig(options?.price_config),
|
|
ratio_config: normalizeRatioConfig(options?.ratio_config),
|
|
sale_price_config: normalizeSalePriceConfig(options?.sale_price_config),
|
|
}
|
|
}
|
|
|
|
function normalizeStringList(values?: unknown[]) {
|
|
return Array.isArray(values)
|
|
? values.map((item) => (typeof item === 'string' ? item.trim() : '')).filter(Boolean)
|
|
: []
|
|
}
|
|
|
|
function normalizeOptionGroups(values?: unknown[]): PublishOptionGroup[] {
|
|
if (!Array.isArray(values)) return []
|
|
return values
|
|
.map((item) => {
|
|
const group = isRecord(item) ? item : {}
|
|
return {
|
|
key: typeof group.key === 'string' ? group.key.trim() : '',
|
|
title: typeof group.title === 'string' ? group.title.trim() : '',
|
|
options: normalizeStringList(Array.isArray(group.options) ? group.options : []),
|
|
}
|
|
})
|
|
.filter((item) => item.key && item.title)
|
|
}
|
|
|
|
function normalizeQuantityItems(values?: unknown[]): PublishQuantityItem[] {
|
|
if (!Array.isArray(values)) return []
|
|
return values
|
|
.map((item) => {
|
|
const row = isRecord(item) ? item : {}
|
|
return {
|
|
key: typeof row.key === 'string' ? row.key.trim() : '',
|
|
label: typeof row.label === 'string' ? row.label.trim() : '',
|
|
price: typeof row.price === 'string' ? row.price.trim() : '',
|
|
placeholder: typeof row.placeholder === 'string' ? row.placeholder.trim() : undefined,
|
|
}
|
|
})
|
|
.filter((item) => item.key && item.label)
|
|
}
|
|
|
|
function normalizeScreenshotSlots(values?: unknown[]): PublishScreenshotSlot[] {
|
|
if (!Array.isArray(values)) return []
|
|
return values
|
|
.map((item) => {
|
|
const row = isRecord(item) ? item : {}
|
|
return {
|
|
key: typeof row.key === 'string' ? row.key.trim() : '',
|
|
label: typeof row.label === 'string' ? row.label.trim() : '',
|
|
required: row.required === true,
|
|
hint: typeof row.hint === 'string' ? row.hint.trim() : '',
|
|
}
|
|
})
|
|
.filter((item) => item.key && item.label)
|
|
}
|
|
|
|
function normalizePriceConfig(value?: unknown): PublishPriceConfig {
|
|
const row = isRecord(value) ? value : {}
|
|
return {
|
|
deposit_placeholder: typeof row.deposit_placeholder === 'string' ? row.deposit_placeholder.trim() : '',
|
|
price_placeholder: typeof row.price_placeholder === 'string' ? row.price_placeholder.trim() : '',
|
|
ratio_description: typeof row.ratio_description === 'string' ? row.ratio_description.trim() : '',
|
|
}
|
|
}
|
|
|
|
function normalizeRatioConfig(value?: unknown): PublishRatioConfig {
|
|
const row = isRecord(value) ? value : {}
|
|
return {
|
|
insurance_base_ratios: normalizeInsuranceBaseRatios(
|
|
Array.isArray(row.insurance_base_ratios) ? row.insurance_base_ratios : [],
|
|
),
|
|
config_items: normalizeRatioConfigItems(
|
|
Array.isArray(row.config_items) ? row.config_items : [],
|
|
),
|
|
coin_corrections: normalizeCoinCorrections(
|
|
Array.isArray(row.coin_corrections) ? row.coin_corrections : [],
|
|
),
|
|
}
|
|
}
|
|
|
|
function normalizeSalePriceConfig(value?: unknown): PublishSalePriceConfig {
|
|
const row = isRecord(value) ? value : {}
|
|
return {
|
|
fixed_markup_rules: normalizeSaleFixedMarkupRules(
|
|
Array.isArray(row.fixed_markup_rules) ? row.fixed_markup_rules : [],
|
|
),
|
|
ratio_adjustment_rules: normalizeSaleRatioAdjustmentRules(
|
|
Array.isArray(row.ratio_adjustment_rules) ? row.ratio_adjustment_rules : [],
|
|
),
|
|
}
|
|
}
|
|
|
|
function normalizeInsuranceBaseRatios(values: unknown[]): PublishInsuranceBaseRatio[] {
|
|
return values
|
|
.map((item) => {
|
|
const row = isRecord(item) ? item : {}
|
|
return {
|
|
insurance: typeof row.insurance === 'string' ? row.insurance.trim() : '',
|
|
ratio: readNumber(row.ratio),
|
|
}
|
|
})
|
|
.filter((item) => item.insurance && item.ratio > 0)
|
|
}
|
|
|
|
function normalizeRatioConfigItems(values: unknown[]): PublishRatioConfigItem[] {
|
|
return values
|
|
.map((item) => {
|
|
const row = isRecord(item) ? item : {}
|
|
return {
|
|
key: typeof row.key === 'string' ? row.key.trim() : '',
|
|
label: typeof row.label === 'string' ? row.label.trim() : '',
|
|
kind: typeof row.kind === 'string' ? row.kind.trim() : '',
|
|
group_key: typeof row.group_key === 'string' ? row.group_key.trim() : '',
|
|
missing_penalty: readNumber(row.missing_penalty),
|
|
}
|
|
})
|
|
.filter((item) => item.key && item.label && item.kind)
|
|
}
|
|
|
|
function normalizeCoinCorrections(values: unknown[]): PublishCoinCorrection[] {
|
|
return values
|
|
.map((item) => {
|
|
const row = isRecord(item) ? item : {}
|
|
return {
|
|
threshold_m: readNumber(row.threshold_m),
|
|
correction: readNumber(row.correction),
|
|
}
|
|
})
|
|
.filter((item) => item.threshold_m >= 0 && item.correction > 0)
|
|
}
|
|
|
|
function normalizeSaleFixedMarkupRules(values: unknown[]): PublishSaleFixedMarkupRule[] {
|
|
return values
|
|
.map((item) => {
|
|
const row = isRecord(item) ? item : {}
|
|
return {
|
|
min_m: readNumber(row.min_m),
|
|
max_m: readNumber(row.max_m),
|
|
markup_amount: readNumber(row.markup_amount),
|
|
}
|
|
})
|
|
.filter((item) => item.min_m >= 0 && item.max_m >= item.min_m && item.markup_amount >= 0)
|
|
}
|
|
|
|
function normalizeSaleRatioAdjustmentRules(values: unknown[]): PublishSaleRatioAdjustmentRule[] {
|
|
return values
|
|
.map((item) => {
|
|
const row = isRecord(item) ? item : {}
|
|
return {
|
|
min_m: readNumber(row.min_m),
|
|
max_m: readNumber(row.max_m),
|
|
ratio_subtract: readNumber(row.ratio_subtract),
|
|
}
|
|
})
|
|
.filter(
|
|
(item) =>
|
|
item.min_m >= 0 &&
|
|
(item.max_m === 0 || item.max_m >= item.min_m) &&
|
|
item.ratio_subtract >= 0,
|
|
)
|
|
}
|
|
|
|
function readNumber(value: unknown) {
|
|
const parsed = Number(value)
|
|
return Number.isFinite(parsed) ? parsed : 0
|
|
}
|
|
|
|
function readPositiveInteger(value: unknown, fallback: number) {
|
|
const parsed = Math.trunc(readNumber(value))
|
|
return parsed > 0 ? parsed : fallback
|
|
}
|
|
|
|
function isRecord(value: unknown): value is Record<string, unknown> {
|
|
return typeof value === 'object' && value !== null
|
|
}
|