kiteticker_async_manager/models/
request.rs

1use serde::{Deserialize, Serialize};
2use std::fmt;
3
4use crate::Mode;
5
6#[derive(Clone, Debug, Deserialize, Serialize)]
7#[serde(rename_all = "lowercase")]
8///
9/// Websocket request actions
10///
11enum RequestActions {
12  Subscribe,
13  Unsubscribe,
14  Mode,
15}
16
17#[derive(Clone, Debug)]
18///
19/// Websocket request data
20///
21enum RequestData<'a> {
22  InstrumentTokens(&'a [u32]),
23  InstrumentTokensWithMode(Mode, &'a [u32]),
24}
25
26// Custom serialization for RequestData
27impl<'a> serde::Serialize for RequestData<'a> {
28  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
29  where
30    S: serde::Serializer,
31  {
32    match self {
33      RequestData::InstrumentTokens(tokens) => tokens.serialize(serializer),
34      RequestData::InstrumentTokensWithMode(mode, tokens) => {
35        // Serialize as [mode_string, tokens_array] according to Kite docs
36        let mode_str = mode.to_websocket_string();
37        let tuple = (mode_str, tokens);
38        tuple.serialize(serializer)
39      }
40    }
41  }
42}
43
44// We don't need custom deserialization for RequestData since it's only used for sending
45impl<'de, 'a> serde::Deserialize<'de> for RequestData<'a> {
46  fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
47  where
48    D: serde::Deserializer<'de>,
49  {
50    // This is only used for outgoing requests, not parsing responses
51    unimplemented!("RequestData deserialization not needed")
52  }
53}
54
55#[derive(Debug, Clone, Deserialize, Serialize)]
56///
57/// Websocket request structure
58///
59pub struct Request<'a> {
60  a: RequestActions,
61  v: RequestData<'a>,
62}
63
64impl<'a> Request<'a> {
65  fn new(action: RequestActions, value: RequestData<'a>) -> Request<'a> {
66    Request {
67      a: action,
68      v: value,
69    }
70  }
71
72  ///
73  /// Subscribe to a list of instrument tokens
74  ///
75  pub fn subscribe(instrument_tokens: &'a [u32]) -> Request<'a> {
76    Request::new(
77      RequestActions::Subscribe,
78      RequestData::InstrumentTokens(instrument_tokens),
79    )
80  }
81
82  ///
83  /// Subscribe to a list of instrument tokens with mode
84  ///
85  pub fn mode(mode: Mode, instrument_tokens: &'a [u32]) -> Request<'a> {
86    Request::new(
87      RequestActions::Mode,
88      RequestData::InstrumentTokensWithMode(mode, instrument_tokens),
89    )
90  }
91
92  ///
93  /// Unsubscribe from a list of instrument tokens
94  ///
95  pub fn unsubscribe(instrument_tokens: &'a [u32]) -> Request<'a> {
96    Request::new(
97      RequestActions::Unsubscribe,
98      RequestData::InstrumentTokens(instrument_tokens),
99    )
100  }
101}
102
103impl<'a> fmt::Display for Request<'a> {
104  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
105    let json =
106      serde_json::to_string(self).expect("failed to serialize Request to JSON");
107    write!(f, "{}", json)
108  }
109}