1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
namespace FundLab.Api
open System
open System.Diagnostics
open System.IO
open System.Security.Cryptography
open System.Text
type MarketDataFailure =
| InvalidMarketDataRequest of string
| MarketDataCollectorUnavailable of string
| InvalidMarketDataPayload of string
| MarketDataPersistenceFailure of string
type IMarketDataCollector =
abstract Search: query: string -> Result<string, string>
abstract FetchNav: code: string -> Result<string, string>
type IMarketDataService =
abstract Search: query: string -> Result<MarketDataSearchPayload, MarketDataFailure>
abstract RefreshNav: code: string -> Result<MarketDataNavRecord list, MarketDataFailure>
abstract GetNav: code: string * fromDate: DateOnly option * toDate: DateOnly option -> Result<MarketDataNavRecord list, MarketDataFailure>
type ProcessMarketDataCollector(pythonExecutable: string, scriptPath: string, pythonPath: string option) =
let execute arguments =
if not (File.Exists scriptPath) then
Error(sprintf "collector script was not found at %s" scriptPath)
else
let startInfo = ProcessStartInfo()
startInfo.FileName <- pythonExecutable
startInfo.UseShellExecute <- false
startInfo.RedirectStandardOutput <- true
startInfo.RedirectStandardError <- true
startInfo.WorkingDirectory <- Path.GetDirectoryName(scriptPath)
startInfo.ArgumentList.Add(scriptPath)
for argument in arguments do
startInfo.ArgumentList.Add(argument)
match pythonPath with
| Some value -> startInfo.Environment["PYTHONPATH"] <- value
| None -> ()
use child = new Process()
child.StartInfo <- startInfo
try
if not (child.Start()) then
Error "could not start the AKShare collector"
else
let output = child.StandardOutput.ReadToEnd()
let error = child.StandardError.ReadToEnd()
child.WaitForExit()
if child.ExitCode = 0 && not (String.IsNullOrWhiteSpace output) then
Ok output
elif String.IsNullOrWhiteSpace error then
Error(sprintf "collector exited with code %d" child.ExitCode)
else
Error(error.Trim())
with error ->
Error(error.Message)
static member FromEnvironment() =
let value name fallback =
Environment.GetEnvironmentVariable(name)
|> Option.ofObj
|> Option.filter (String.IsNullOrWhiteSpace >> not)
|> Option.defaultValue fallback
let python = value "FUND_LAB_AKSHARE_PYTHON" "python3"
let script = Path.Combine(AppContext.BaseDirectory, "akshare_collector.py")
let pythonPath =
Environment.GetEnvironmentVariable("FUND_LAB_AKSHARE_PYTHONPATH")
|> Option.ofObj
|> Option.filter (String.IsNullOrWhiteSpace >> not)
ProcessMarketDataCollector(python, script, pythonPath)
interface IMarketDataCollector with
member _.Search(query: string) =
execute [ "--operation"; "search"; "--query"; query ]
member _.FetchNav(code: string) =
execute [ "--operation"; "nav"; "--code"; code ]
type MarketDataService(repository: FundRepository, collector: IMarketDataCollector) =
let codePattern = Text.RegularExpressions.Regex("^[0-9]{6}$", Text.RegularExpressions.RegexOptions.Compiled)
let payloadHash (raw: string) =
Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(raw)))
let collectorFailure error = MarketDataCollectorUnavailable error
let payloadFailure error = InvalidMarketDataPayload error
let parseSearch raw =
match MarketData.parseSearchPayload raw with
| Ok payload -> Ok(payload, payloadHash raw)
| Error message -> Error(payloadFailure message)
let parseNav raw =
match MarketData.parseNavPayload raw with
| Ok payload -> Ok(payload, payloadHash raw)
| Error message -> Error(payloadFailure message)
let persistSearch (payload: MarketDataSearchPayload) hash =
try
repository.UpsertInstruments(payload, hash)
Ok payload
with error ->
Error(MarketDataPersistenceFailure error.Message)
let persistNav (payload: MarketDataNavPayload) hash =
try
repository.UpsertNavObservations(payload, hash)
Ok(repository.GetNav(payload.Code, None, None))
with error ->
Error(MarketDataPersistenceFailure error.Message)
let validCode code =
not (String.IsNullOrWhiteSpace code) && codePattern.IsMatch(code)
member _.Search(query: string) =
let normalizedQuery = if isNull query then "" else query.Trim()
if String.IsNullOrWhiteSpace normalizedQuery || normalizedQuery.Length > 80 then
Error(InvalidMarketDataRequest "search query must contain 1 to 80 characters")
else
match collector.Search normalizedQuery with
| Error message -> Error(collectorFailure message)
| Ok raw ->
match parseSearch raw with
| Error failure -> Error failure
| Ok(payload, hash) -> persistSearch payload hash
member _.RefreshNav(code: string) =
let normalizedCode = if isNull code then "" else code.Trim()
if not (validCode normalizedCode) then
Error(InvalidMarketDataRequest "fund code must contain exactly six digits")
else
match collector.Search normalizedCode with
| Error message -> Error(collectorFailure message)
| Ok searchRaw ->
match parseSearch searchRaw with
| Error failure -> Error failure
| Ok(searchPayload, searchHash) ->
match searchPayload.Instruments |> List.tryFind (fun instrument -> instrument.Code = normalizedCode) with
| None -> Error(InvalidMarketDataRequest "fund code was not found in the source catalog")
| Some _ ->
match persistSearch searchPayload searchHash with
| Error failure -> Error failure
| Ok _ ->
match collector.FetchNav normalizedCode with
| Error message -> Error(collectorFailure message)
| Ok navRaw ->
match parseNav navRaw with
| Error failure -> Error failure
| Ok(navPayload, navHash) when navPayload.Code <> normalizedCode ->
Error(payloadFailure "NAV payload code does not match the requested fund code")
| Ok(navPayload, navHash) -> persistNav navPayload navHash
member _.GetNav(code: string, fromDate: DateOnly option, toDate: DateOnly option) =
let normalizedCode = if isNull code then "" else code.Trim()
if not (validCode normalizedCode) then
Error(InvalidMarketDataRequest "fund code must contain exactly six digits")
elif fromDate.IsSome && toDate.IsSome && fromDate.Value > toDate.Value then
Error(InvalidMarketDataRequest "from date must not be after to date")
else
try
Ok(repository.GetNav(normalizedCode, fromDate, toDate))
with error ->
Error(MarketDataPersistenceFailure error.Message)
interface IMarketDataService with
member this.Search(query) = this.Search(query)
member this.RefreshNav(code) = this.RefreshNav(code)
member this.GetNav(code, fromDate, toDate) = this.GetNav(code, fromDate, toDate)
|
