longbridge 4.2.0

Longbridge OpenAPI SDK for Rust
Documentation 
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

use std::sync::Arc;

use tokio::sync::mpsc;

use crate::{
    Config, Result,
    blocking::runtime::BlockingRuntime,
    dca::{DCAContext, types::*},
};

/// Blocking dollar-cost averaging (DCA) plan management context.
pub struct DCAContextSync {
    rt: BlockingRuntime<DCAContext>,
}

impl DCAContextSync {
    /// Create a [`DCAContextSync`]
    pub fn new(config: Arc<Config>) -> Result<Self> {
        let rt = BlockingRuntime::try_new(
            move || {
                let ctx = DCAContext::new(config);
                let (tx, rx) = mpsc::unbounded_channel::<std::convert::Infallible>();
                std::mem::forget(tx);
                Ok::<_, crate::Error>((ctx, rx))
            },
            |_: std::convert::Infallible| {},
        )?;
        Ok(Self { rt })
    }
    /// List DCA plans.
    pub fn list(&self, status: Option<DCAStatus>, symbol: Option<String>) -> Result<DcaList> {
        self.rt
            .call(move |ctx| async move { ctx.list(status, symbol).await })
    }
    /// Create a new DCA plan.
    pub fn create(
        &self,
        symbol: impl Into<String> + Send + 'static,
        amount: impl Into<String> + Send + 'static,
        frequency: DCAFrequency,
        day_of_week: Option<String>,
        day_of_month: Option<u32>,
        allow_margin: bool,
    ) -> Result<DcaCreateResult> {
        self.rt.call(move |ctx| async move {
            ctx.create(
                symbol,
                amount,
                frequency,
                day_of_week,
                day_of_month,
                allow_margin,
            )
            .await
        })
    }
    /// Update a DCA plan.
    pub fn update(
        &self,
        plan_id: impl Into<String> + Send + 'static,
        amount: Option<String>,
        frequency: Option<DCAFrequency>,
        day_of_week: Option<String>,
        day_of_month: Option<u32>,
        allow_margin: Option<bool>,
    ) -> Result<DcaCreateResult> {
        self.rt.call(move |ctx| async move {
            ctx.update(
                plan_id,
                amount,
                frequency,
                day_of_week,
                day_of_month,
                allow_margin,
            )
            .await
        })
    }
    /// Pause a DCA plan.
    pub fn pause(&self, plan_id: impl Into<String> + Send + 'static) -> Result<()> {
        self.rt
            .call(move |ctx| async move { ctx.pause(plan_id).await })
    }
    /// Resume a suspended DCA plan.
    pub fn resume(&self, plan_id: impl Into<String> + Send + 'static) -> Result<()> {
        self.rt
            .call(move |ctx| async move { ctx.resume(plan_id).await })
    }
    /// Stop (permanently finish) a DCA plan.
    pub fn stop(&self, plan_id: impl Into<String> + Send + 'static) -> Result<()> {
        self.rt
            .call(move |ctx| async move { ctx.stop(plan_id).await })
    }
    /// Get execution history for a DCA plan.
    pub fn history(
        &self,
        plan_id: impl Into<String> + Send + 'static,
        page: i32,
        limit: i32,
    ) -> Result<DcaHistoryResponse> {
        self.rt
            .call(move |ctx| async move { ctx.history(plan_id, page, limit).await })
    }
    /// Get DCA statistics.
    pub fn stats(&self, symbol: Option<String>) -> Result<DcaStats> {
        self.rt
            .call(move |ctx| async move { ctx.stats(symbol).await })
    }
    /// Check DCA support for a list of securities.
    pub fn check_support(&self, symbols: Vec<String>) -> Result<DcaSupportList> {
        self.rt
            .call(move |ctx| async move { ctx.check_support(symbols).await })
    }
    /// Calculate the next projected trade date for a DCA plan.
    pub fn calc_date(
        &self,
        symbol: impl Into<String> + Send + 'static,
        frequency: DCAFrequency,
        day_of_week: Option<String>,
        day_of_month: Option<u32>,
    ) -> Result<DcaCalcDateResult> {
        self.rt.call(move |ctx| async move {
            ctx.calc_date(symbol, frequency, day_of_week, day_of_month)
                .await
        })
    }
    /// Update the advance reminder hours for DCA execution notifications.
    pub fn set_reminder(&self, hours: impl Into<String> + Send + 'static) -> Result<()> {
        self.rt
            .call(move |ctx| async move { ctx.set_reminder(hours).await })
    }
}