Skip to main content

financial_api/models/
fund.rs

1use serde::Deserialize;
2
3use crate::{
4    Adjustment, CompanyId, Cursor, DailyInterval, FundCategoryCode, HolderRecordScope, ManagerId,
5    PortfolioAssetType, ReportType, Thscode, UnixMillis,
6};
7
8use super::{PriceBarItem, TimestampedItems};
9
10#[derive(Debug, Clone, PartialEq, Deserialize)]
11pub struct FundProfileItem {
12    pub thscode: Thscode,
13    pub ticker: String,
14    pub fund_name: Option<String>,
15    pub estab_date: Option<UnixMillis>,
16    pub company_id: Option<CompanyId>,
17    pub mgmt_name: Option<String>,
18    pub manager_name: Option<String>,
19    pub fund_scale: Option<f64>,
20    pub unit_nav: Option<f64>,
21    #[serde(default)]
22    pub manager_info: Vec<FundManagerRef>,
23    #[serde(default)]
24    pub trade_rule: Vec<FundTradeRule>,
25    #[serde(default)]
26    pub rate_info: Vec<FundRateInfo>,
27}
28
29#[derive(Debug, Clone, PartialEq, Deserialize)]
30pub struct FundManagerRef {
31    pub manager_id: ManagerId,
32    pub manager_name: String,
33    pub tenure_return_pct: Option<f64>,
34    pub tenure_days: Option<u64>,
35    pub start_date_ms: Option<UnixMillis>,
36    pub end_date_ms: Option<UnixMillis>,
37}
38
39#[derive(Debug, Clone, PartialEq, Deserialize)]
40pub struct FundTradeRule {
41    pub title: Option<String>,
42    pub display_time: Option<String>,
43    pub time_ms: Option<UnixMillis>,
44}
45
46#[derive(Debug, Clone, PartialEq, Deserialize)]
47pub struct FundRateInfo {
48    pub rate_type: Option<String>,
49    pub charge_mode: Option<String>,
50    pub condition: Option<String>,
51    pub standard_rate: Option<String>,
52    pub discounted_rate: Option<String>,
53}
54
55pub type FundProfileData = TimestampedItems<FundProfileItem>;
56
57#[derive(Debug, Clone, PartialEq, Deserialize)]
58pub struct FundHoldingsData {
59    pub timestamp: UnixMillis,
60    pub item: Vec<FundHoldingItem>,
61    pub total_stock_ratio_pct: Option<f64>,
62    pub total_bond_ratio_pct: Option<f64>,
63    pub total_fund_ratio_pct: Option<f64>,
64    pub turnover_rate_pct: Option<f64>,
65    pub stock_ratio_pct: Option<f64>,
66    pub main_industry: Option<String>,
67    pub concentration_ratio: Option<f64>,
68}
69
70#[derive(Debug, Clone, PartialEq, Deserialize)]
71pub struct FundHoldingItem {
72    pub thscode: Option<Thscode>,
73    pub ticker: Option<String>,
74    pub stock_name: Option<String>,
75    pub hold_ratio: Option<f64>,
76    pub asset_type: Option<PortfolioAssetType>,
77    pub position_capital: Option<f64>,
78    pub position_count: Option<f64>,
79    pub security_market_value_rate_pct: Option<f64>,
80    pub period_increase_rate_pct: Option<f64>,
81    pub investment_rank: Option<u64>,
82    pub start_date_ms: Option<UnixMillis>,
83    pub end_date_ms: Option<UnixMillis>,
84    pub publish_date_ms: Option<UnixMillis>,
85    pub modify_time_ms: Option<UnixMillis>,
86}
87
88pub type FundNavData = TimestampedItems<FundNavItem>;
89
90#[derive(Debug, Clone, PartialEq, Deserialize)]
91pub struct FundNavItem {
92    pub nav_date: UnixMillis,
93    pub unit_nav: Option<f64>,
94    pub adj_nav: Option<f64>,
95}
96
97pub type FundReturnsData = TimestampedItems<FundReturnsItem>;
98
99#[derive(Debug, Clone, PartialEq, Deserialize)]
100pub struct FundReturnsItem {
101    pub return_week: Option<f64>,
102    pub return_month: Option<f64>,
103    pub return_tmonth: Option<f64>,
104    pub return_hyear: Option<f64>,
105    pub return_year: Option<f64>,
106    pub return_twoyear: Option<f64>,
107    pub return_tyear: Option<f64>,
108    pub return_fyear: Option<f64>,
109    pub return_nowyear: Option<f64>,
110    pub return_now: Option<f64>,
111    pub peer_average_week: Option<f64>,
112    pub peer_average_month: Option<f64>,
113    pub peer_average_tmonth: Option<f64>,
114    pub peer_average_hyear: Option<f64>,
115    pub peer_average_year: Option<f64>,
116    pub peer_average_twoyear: Option<f64>,
117    pub peer_average_tyear: Option<f64>,
118    pub peer_average_fyear: Option<f64>,
119    pub rank_week: Option<u64>,
120    pub rank_month: Option<u64>,
121    pub rank_tmonth: Option<u64>,
122    pub rank_hyear: Option<u64>,
123    pub rank_year: Option<u64>,
124    pub rank_twoyear: Option<u64>,
125    pub rank_tyear: Option<u64>,
126    pub rank_fyear: Option<u64>,
127    pub rank_total_week: Option<u64>,
128    pub rank_total_month: Option<u64>,
129    pub rank_total_tmonth: Option<u64>,
130    pub rank_total_hyear: Option<u64>,
131    pub rank_total_year: Option<u64>,
132    pub rank_total_twoyear: Option<u64>,
133    pub rank_total_tyear: Option<u64>,
134    pub rank_total_fyear: Option<u64>,
135}
136
137pub type FundHoldersData = TimestampedItems<FundHolderItem>;
138
139#[derive(Debug, Clone, PartialEq, Deserialize)]
140pub struct FundHolderItem {
141    pub merge_scope: HolderRecordScope,
142    pub report_date_ms: UnixMillis,
143    pub ins_position: Option<f64>,
144    pub holder_amount: Option<u64>,
145    pub avg_holder_share: Option<f64>,
146    pub psnl_rate: Option<f64>,
147    pub mgmt_staff_hold_rate: Option<f64>,
148}
149
150#[derive(Debug, Clone, PartialEq, Deserialize)]
151pub struct FundTopHoldersData {
152    pub timestamp: UnixMillis,
153    pub limit: u8,
154    pub item: Vec<FundTopHolderItem>,
155}
156
157#[derive(Debug, Clone, PartialEq, Deserialize)]
158pub struct FundTopHolderItem {
159    pub holder_id: Option<String>,
160    pub holder_code: Option<String>,
161    pub holder_name: Option<String>,
162    pub holder_type: Option<String>,
163    pub rank: Option<u64>,
164    pub hold_share: Option<f64>,
165    pub hold_rate_pct: Option<f64>,
166    pub report_date_ms: Option<UnixMillis>,
167    pub publish_date_ms: Option<UnixMillis>,
168}
169
170#[derive(Debug, Clone, PartialEq, Deserialize)]
171pub struct FundDividendsData {
172    pub timestamp: UnixMillis,
173    pub dividend_count: Option<u64>,
174    pub dividend_total: Option<f64>,
175    pub item: Vec<FundDividendItem>,
176}
177
178#[derive(Debug, Clone, PartialEq, Deserialize)]
179pub struct FundDividendItem {
180    pub per_ten_cash_before_tax: Option<f64>,
181    pub per_ten_cash_after_tax: Option<f64>,
182    pub progress: Option<String>,
183    pub publish_date_ms: Option<UnixMillis>,
184    pub registration_date_ms: Option<UnixMillis>,
185    pub ex_dividend_date_ms: Option<UnixMillis>,
186    pub payment_date_ms: Option<UnixMillis>,
187    pub reinvestment_date_ms: Option<UnixMillis>,
188    pub profit_base_date_ms: Option<UnixMillis>,
189    pub in_dividend_date_ms: Option<UnixMillis>,
190}
191
192pub type FundDiagnosticsData = TimestampedItems<FundDiagnosticsItem>;
193
194#[derive(Debug, Clone, PartialEq, Deserialize)]
195pub struct FundDiagnosticsItem {
196    pub thscode: Thscode,
197    pub ticker: String,
198    pub fund_type: FundCategoryCode,
199    pub peer_code: String,
200    pub dimensions: serde_json::Value,
201    pub peer_dimensions: serde_json::Value,
202    pub probabilities: serde_json::Value,
203    pub ranges: serde_json::Value,
204    pub resilience: serde_json::Value,
205    pub peer_resilience: serde_json::Value,
206}
207
208pub type FundFinancialIndicatorsData = TimestampedItems<FundFinancialIndicatorsItem>;
209
210#[derive(Debug, Clone, PartialEq, Deserialize)]
211pub struct FundFinancialIndicatorsItem {
212    pub start_date_ms: Option<UnixMillis>,
213    pub end_date_ms: Option<UnixMillis>,
214    pub publish_date_ms: Option<UnixMillis>,
215    pub distribution_profit: Option<f64>,
216    pub current_profit: Option<f64>,
217    pub current_income: Option<f64>,
218    pub distribution_share_profit: Option<f64>,
219    pub average_nav_profit_margin: Option<f64>,
220    pub average_share_current_profit: Option<f64>,
221    pub share_nav: Option<f64>,
222    pub sum_share_nav: Option<f64>,
223    pub asset_nav: Option<f64>,
224    pub sum_nav_rate: Option<f64>,
225    pub nav_rate: Option<f64>,
226}
227
228pub type FundIncomeStatementsData = TimestampedItems<FundIncomeStatementItem>;
229
230#[derive(Debug, Clone, PartialEq, Deserialize)]
231pub struct FundIncomeStatementItem {
232    pub start_date_ms: Option<UnixMillis>,
233    pub end_date_ms: Option<UnixMillis>,
234    pub publish_date_ms: Option<UnixMillis>,
235    pub income: Option<f64>,
236    pub investment_income: Option<f64>,
237    pub stock_investment_income: Option<f64>,
238    pub bond_investment_income: Option<f64>,
239    pub fund_investment_income: Option<f64>,
240    pub dividend_income: Option<f64>,
241    pub interest_income: Option<f64>,
242    pub fair_value_income: Option<f64>,
243    pub exchange_income: Option<f64>,
244    pub other_income: Option<f64>,
245    pub total_income: Option<f64>,
246    pub fee: Option<f64>,
247    pub manager_reward: Option<f64>,
248    pub custodian_fee: Option<f64>,
249    pub transaction_cost: Option<f64>,
250    pub tax_surcharge: Option<f64>,
251    pub total_fee: Option<f64>,
252    pub total_profit: Option<f64>,
253    pub net_profit: Option<f64>,
254}
255
256pub type FundBalanceSheetsData = TimestampedItems<FundBalanceSheetItem>;
257
258#[derive(Debug, Clone, PartialEq, Deserialize)]
259pub struct FundBalanceSheetItem {
260    pub start_date_ms: Option<UnixMillis>,
261    pub end_date_ms: Option<UnixMillis>,
262    pub publish_date_ms: Option<UnixMillis>,
263    pub total_assets: Option<f64>,
264    pub bank_deposit: Option<f64>,
265    pub fund_investment: Option<f64>,
266    pub stock_investment: Option<f64>,
267    pub bond_investment: Option<f64>,
268    pub transactional_financial_assets: Option<f64>,
269    pub other_assets: Option<f64>,
270    pub total_liability: Option<f64>,
271    pub other_liability: Option<f64>,
272    pub owner_total_equity: Option<f64>,
273    pub undistributed_profit: Option<f64>,
274    pub liability_and_owner_equity: Option<f64>,
275}
276
277pub type FundCompanyData = TimestampedItems<FundCompanyItem>;
278
279#[derive(Debug, Clone, PartialEq, Deserialize)]
280pub struct FundCompanyItem {
281    pub company_id: CompanyId,
282    pub company_name: String,
283    pub company_type: String,
284    pub established_date_ms: UnixMillis,
285    pub fund_count: u64,
286    pub scale: f64,
287}
288
289pub type FundIndustryAllocationData = TimestampedItems<FundIndustryAllocationItem>;
290
291#[derive(Debug, Clone, PartialEq, Deserialize)]
292pub struct FundIndustryAllocationItem {
293    pub report_period: Option<String>,
294    pub industry_name: Option<String>,
295    pub ratio_pct: Option<f64>,
296}
297
298pub type FundIndicatorHistoryData = TimestampedItems<FundIndicatorHistoryItem>;
299
300#[derive(Debug, Clone, PartialEq, Deserialize)]
301pub struct FundIndicatorHistoryItem {
302    pub date_ms: UnixMillis,
303    pub rsi_pct: Option<f64>,
304    pub donchian_channel: Option<f64>,
305    pub track_index_pe_ttm_five_year_percentile: Option<f64>,
306}
307
308pub type FundDrawdownsData = TimestampedItems<FundDrawdownsItem>;
309
310#[derive(Debug, Clone, PartialEq, Deserialize)]
311pub struct FundDrawdownsItem {
312    pub thscode: Thscode,
313    pub ticker: String,
314    pub week: Option<f64>,
315    pub month: Option<f64>,
316    pub tmonth: Option<f64>,
317    pub hyear: Option<f64>,
318    pub year: Option<f64>,
319    pub twoyear: Option<f64>,
320    pub tyear: Option<f64>,
321    pub fyear: Option<f64>,
322    pub nowyear: Option<f64>,
323    pub now: Option<f64>,
324}
325
326pub type FundManagerStyleData = TimestampedItems<FundManagerStyleItem>;
327
328#[derive(Debug, Clone, PartialEq, Deserialize)]
329pub struct FundManagerStyleItem {
330    pub representative_fund_thscode: Option<Thscode>,
331    pub representative_fund_ticker: Option<String>,
332    pub representative_fund_name: Option<String>,
333    pub investment_idea: Option<String>,
334    pub total_fund_scale: Option<f64>,
335    pub industry_preferences: Option<serde_json::Value>,
336}
337
338pub type FundManagerPerformanceData = TimestampedItems<FundManagerPerformanceItem>;
339
340#[derive(Debug, Clone, PartialEq, Deserialize)]
341pub struct FundManagerPerformanceItem {
342    pub date_ms: UnixMillis,
343    pub manager_return_pct: Option<f64>,
344    pub peer_return_pct: Option<f64>,
345    pub benchmark_return_pct: Option<f64>,
346}
347
348pub type FundManagerExperienceData = TimestampedItems<FundManagerExperienceItem>;
349
350#[derive(Debug, Clone, PartialEq, Deserialize)]
351pub struct FundManagerExperienceItem {
352    pub awards: serde_json::Value,
353    pub heavy_assets: serde_json::Value,
354    pub investment_history: serde_json::Value,
355}
356
357pub type FundManagerDetailData = TimestampedItems<FundManagerDetailItem>;
358
359#[derive(Debug, Clone, PartialEq, Deserialize)]
360pub struct FundManagerDetailItem {
361    pub manager_id: ManagerId,
362    pub manager_name: String,
363    pub sex: Option<String>,
364    pub degree: Option<String>,
365    pub company_id: Option<CompanyId>,
366    pub company_name: Option<String>,
367    pub resume: Option<String>,
368    pub photo_url: Option<String>,
369    pub annual_return_pct: Option<f64>,
370    pub maximum_return_pct: Option<f64>,
371    pub radar_comparison: Vec<FundManagerRadarComparison>,
372}
373
374/// 按类别和区间对齐的一项基金经理同类比较雷达节点。
375#[derive(Debug, Clone, PartialEq, Deserialize)]
376pub struct FundManagerRadarComparison {
377    pub fund_category: Option<String>,
378    pub horizon: Option<String>,
379    pub manager_metrics: Option<serde_json::Value>,
380    pub manager_scores: Option<serde_json::Value>,
381    pub peer_average_scores: Option<serde_json::Value>,
382}
383
384#[derive(Debug, Clone, PartialEq, Deserialize)]
385pub struct FundMarketSnapshotData {
386    pub timestamp: Option<UnixMillis>,
387    pub item: Vec<FundMarketSnapshotItem>,
388}
389
390#[derive(Debug, Clone, PartialEq, Deserialize)]
391pub struct FundMarketSnapshotItem {
392    pub thscode: Thscode,
393    pub ticker: String,
394    pub last_price: f64,
395    pub open_price: f64,
396    pub high_price: f64,
397    pub low_price: f64,
398    pub prev_price: f64,
399    pub price_change_ratio_pct: f64,
400    pub price_change: f64,
401    pub price_amplitude_ratio_pct: Option<f64>,
402    pub volume: f64,
403    pub turnover: f64,
404    pub turnover_ratio_pct: Option<f64>,
405}
406
407#[derive(Debug, Clone, PartialEq, Deserialize)]
408pub struct FundMarketHistoricalData {
409    pub timestamp: UnixMillis,
410    pub thscode: Thscode,
411    pub interval: DailyInterval,
412    pub adjust: Option<Adjustment>,
413    pub item: Vec<PriceBarItem>,
414}
415
416#[derive(Debug, Clone, PartialEq, Deserialize)]
417pub struct FundNewsData {
418    pub timestamp: UnixMillis,
419    pub limit: u32,
420    pub offset: Option<Cursor>,
421    pub has_more: bool,
422    pub item: Vec<FundNewsItem>,
423}
424
425#[derive(Debug, Clone, PartialEq, Deserialize)]
426pub struct FundNewsItem {
427    pub id: String,
428    pub content_type: Option<String>,
429    pub title: String,
430    pub summary: Option<String>,
431    pub source: Option<String>,
432    pub url: Option<String>,
433    pub image_url: Option<String>,
434    pub author: Option<String>,
435    pub publish_time_ms: Option<UnixMillis>,
436    pub top: Option<bool>,
437}
438
439pub type FundOfferingsData = TimestampedItems<FundOfferingItem>;
440
441#[derive(Debug, Clone, PartialEq, Deserialize)]
442pub struct FundOfferingItem {
443    pub thscode: Option<Thscode>,
444    pub ticker: String,
445    pub subscription_start_ms: Option<UnixMillis>,
446    pub subscription_end_ms: Option<UnixMillis>,
447}
448
449pub type FundPortfolioHistoryData = TimestampedItems<FundPortfolioHistoryItem>;
450
451#[derive(Debug, Clone, PartialEq, Deserialize)]
452pub struct FundPortfolioHistoryItem {
453    pub thscode: Option<Thscode>,
454    pub ticker: Option<String>,
455    pub name: Option<String>,
456    pub asset_type: PortfolioAssetType,
457    pub hold_ratio: Option<f64>,
458    pub market_value: Option<f64>,
459    pub period_increase_pct: Option<f64>,
460    pub rank: Option<u64>,
461    pub report_type: ReportType,
462    pub end_date_ms: UnixMillis,
463}
464
465pub type FundReportDatesData = TimestampedItems<FundReportDateItem>;
466
467#[derive(Debug, Clone, PartialEq, Deserialize)]
468pub struct FundReportDateItem {
469    pub report_type: ReportType,
470    pub report_type_name: String,
471    pub start_date_ms: UnixMillis,
472    pub end_date_ms: UnixMillis,
473}
474
475pub type FundAssetAllocationData = TimestampedItems<FundAssetAllocationItem>;
476
477#[derive(Debug, Clone, PartialEq, Deserialize)]
478pub struct FundAssetAllocationItem {
479    pub report_date_ms: Option<UnixMillis>,
480    pub stock_ratio_pct: Option<f64>,
481    pub bond_ratio_pct: Option<f64>,
482    pub deposit_ratio_pct: Option<f64>,
483    pub other_ratio_pct: Option<f64>,
484}
485
486#[cfg(test)]
487mod tests {
488    use serde_json::json;
489
490    use crate::{
491        FundAssetAllocationData, FundDiagnosticsData, FundHoldersData, FundManagerDetailData,
492        FundMarketHistoricalData, FundMarketSnapshotData, FundNavData, FundPortfolioHistoryData,
493        FundProfileData,
494    };
495
496    #[test]
497    fn profile_preserves_unit_bearing_rate_text() {
498        let profile: FundProfileData = serde_json::from_value(json!({
499            "timestamp": 1_i64,
500            "item": [{
501                "thscode": "025480.OF",
502                "ticker": "025480",
503                "rate_info": [
504                    {
505                        "rate_type": "purchase",
506                        "standard_rate": "1.20%",
507                        "discounted_rate": "0.12%"
508                    },
509                    {
510                        "rate_type": "purchase",
511                        "standard_rate": "500元/笔",
512                        "discounted_rate": "500元/笔"
513                    }
514                ]
515            }]
516        }))
517        .unwrap();
518
519        assert_eq!(
520            profile.item[0].rate_info[0].discounted_rate.as_deref(),
521            Some("0.12%")
522        );
523        assert_eq!(
524            profile.item[0].rate_info[1].standard_rate.as_deref(),
525            Some("500元/笔")
526        );
527    }
528
529    #[test]
530    fn diagnostics_preserves_the_observed_fund_category_code() {
531        let diagnostics: FundDiagnosticsData = serde_json::from_value(json!({
532            "timestamp": 1_i64,
533            "item": [{
534                "thscode": "025480.OF",
535                "ticker": "025480",
536                "fund_type": "282001003",
537                "peer_code": "000300.SH",
538                "dimensions": [],
539                "peer_dimensions": [],
540                "probabilities": [],
541                "ranges": [],
542                "resilience": [],
543                "peer_resilience": []
544            }]
545        }))
546        .unwrap();
547
548        assert_eq!(diagnostics.item[0].fund_type.as_str(), "282001003");
549    }
550
551    #[test]
552    fn asset_allocation_preserves_a_missing_report_date() {
553        let allocation: FundAssetAllocationData = serde_json::from_value(json!({
554            "timestamp": 1_i64,
555            "item": [{
556                "report_date_ms": null,
557                "stock_ratio_pct": 90.34,
558                "bond_ratio_pct": 0,
559                "deposit_ratio_pct": 9.25,
560                "other_ratio_pct": 0.4
561            }]
562        }))
563        .unwrap();
564
565        assert_eq!(allocation.item[0].report_date_ms, None);
566    }
567
568    #[test]
569    fn historical_response_preserves_the_documented_adjustment_marker() {
570        let data: FundMarketHistoricalData = serde_json::from_value(json!({
571            "timestamp": 1_716_105_600_000_i64,
572            "thscode": "510300.SH",
573            "interval": "1d",
574            "adjust": null,
575            "item": []
576        }))
577        .unwrap();
578
579        assert_eq!(data.adjust, None);
580    }
581
582    #[test]
583    fn nav_date_is_a_validated_unix_millisecond_value() {
584        let data: FundNavData = serde_json::from_value(json!({
585            "timestamp": 1_784_131_200_000_i64,
586            "item": [{
587                "nav_date": 1_752_595_200_000_i64,
588                "unit_nav": 4.0713
589            }]
590        }))
591        .unwrap();
592
593        assert_eq!(data.item[0].nav_date.get(), 1_752_595_200_000);
594        assert_eq!(data.item[0].adj_nav, None);
595    }
596
597    #[test]
598    fn finite_response_states_reject_unknown_wire_values() {
599        let holders = json!({
600            "timestamp": 1_i64,
601            "item": [{"merge_scope": "all", "report_date_ms": 1_i64}]
602        });
603        assert!(serde_json::from_value::<FundHoldersData>(holders).is_err());
604
605        let portfolio = json!({
606            "timestamp": 1_i64,
607            "item": [{
608                "asset_type": "crypto",
609                "report_type": "quarter",
610                "end_date_ms": 1_i64
611            }]
612        });
613        assert!(serde_json::from_value::<FundPortfolioHistoryData>(portfolio).is_err());
614
615        let historical = json!({
616            "timestamp": 1_i64,
617            "thscode": "510300.SH",
618            "interval": "1h",
619            "adjust": null,
620            "item": []
621        });
622        assert!(serde_json::from_value::<FundMarketHistoricalData>(historical).is_err());
623    }
624
625    #[test]
626    fn documented_nullable_snapshot_metadata_is_preserved() {
627        let snapshot: FundMarketSnapshotData = serde_json::from_value(json!({
628            "timestamp": null,
629            "item": []
630        }))
631        .unwrap();
632
633        assert_eq!(snapshot.timestamp, None);
634    }
635
636    #[test]
637    fn manager_detail_requires_the_documented_radar_collection() {
638        let without_radar = json!({
639            "timestamp": 1_i64,
640            "item": [{"manager_id": "manager-1", "manager_name": "测试经理"}]
641        });
642
643        assert!(serde_json::from_value::<FundManagerDetailData>(without_radar).is_err());
644
645        let detail: FundManagerDetailData = serde_json::from_value(json!({
646            "timestamp": 1_i64,
647            "item": [{
648                "manager_id": "manager-1",
649                "manager_name": "测试经理",
650                "radar_comparison": [{
651                    "fund_category": "equity",
652                    "horizon": "year",
653                    "manager_metrics": {"annual_return_pct": 8.6},
654                    "manager_scores": {"annual_return": 80},
655                    "peer_average_scores": {"annual_return": 50}
656                }]
657            }]
658        }))
659        .unwrap();
660
661        let radar = &detail.item[0].radar_comparison[0];
662        assert_eq!(radar.fund_category.as_deref(), Some("equity"));
663        assert_eq!(radar.horizon.as_deref(), Some("year"));
664        assert_eq!(
665            radar.manager_scores.as_ref().unwrap()["annual_return"],
666            json!(80)
667        );
668    }
669
670    #[test]
671    fn manager_detail_preserves_incomplete_radar_placeholders() {
672        let detail: FundManagerDetailData = serde_json::from_value(json!({
673            "timestamp": 1_i64,
674            "item": [{
675                "manager_id": "H002417139",
676                "manager_name": "测试经理",
677                "radar_comparison": [{}]
678            }]
679        }))
680        .unwrap();
681
682        let radar = &detail.item[0].radar_comparison[0];
683        assert_eq!(radar.fund_category, None);
684        assert_eq!(radar.horizon, None);
685        assert_eq!(radar.manager_metrics, None);
686        assert_eq!(radar.manager_scores, None);
687        assert_eq!(radar.peer_average_scores, None);
688    }
689}