telegram-client 1.8.1

Telegram client
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

use rtdlib::types as rtd_types;
use rtdlib::types::RObject;

use crate::api::Api;
use crate::errors::TGError;
use crate::listener::lasync::RasyncLout;
use crate::listener::levent::EventLout;
use crate::observer;
use crate::tip;

pub struct Handler<'a> {
  api: &'a Api,
  event_lout: &'a EventLout,
  rasync_lout: &'a RasyncLout,
  warn_unregister_listener: &'a bool,
}

impl<'a> Handler<'a> {
  pub(crate) fn new(
    api: &'a Api,
    event_lout: &'a EventLout,
    rasync_lout: &'a RasyncLout,
    warn_unregister_listener: &'a bool
  ) -> Self {
    Self {
      api,
      event_lout,
      rasync_lout,
      warn_unregister_listener,
    }
  }

  pub async fn handle(&self, json: &'a String) {
    // event listener
    if let Some(ev) = self.event_lout.receive() {
      if let Err(e) = ev((self.api, json)) {
        if let Some(ev) = self.event_lout.exception() {
          ev((self.api, &e));
        }
      }
    }
    // async listener
    if let Some(ev) = self.rasync_lout.receive() {
      if let Err(e) = ev((self.api.clone(), json.clone())).await {
        if let Some(ev) = self.rasync_lout.exception() {
          ev((self.api.clone(), e)).await;
        }
      }
    }

    match rtd_types::from_json::<rtd_types::TdType>(json) {
      Ok(t) => {

        // observer handler
        observer::notify(t.clone());

        // event listener
        match self.event_lout.handle_type(self.api, &t) {
          Ok(true) => return,
          Ok(false) => {
            if *self.warn_unregister_listener {
              warn!("{}", tip::un_register_listener(t.td_name()));
            }
          }
          Err(_err) => {
            if let Some(ev) = self.event_lout.exception() {
              ev((self.api, &TGError::new("EVENT_HANDLER_ERROR")));
            }
          }
        }

        // async listener
        match self.rasync_lout.handle_type(self.api, &t).await {
          Ok(true) => return,
          Ok(false) => {
            if *self.warn_unregister_listener {
              warn!("{}", tip::un_register_listener(t.td_name()));
            }
          }
          Err(_err) => {
            if let Some(ev) = self.rasync_lout.exception() {
              ev((self.api.clone(), TGError::new("EVENT_HANDLER_ERROR"))).await;
            }
          }
        }

      }
      Err(e) => {
        error!("{}", tip::data_fail_with_json(json));
        // eprintln!("{:?}", e);
        error!("{:?}", e);
        // event listener
        if let Some(ev) = self.event_lout.exception() {
          ev((self.api, &TGError::new("DESERIALIZE_JSON_FAIL")));
        }
        // async listener
        if let Some(ev) = self.rasync_lout.exception() {
          ev((self.api.clone(), TGError::new("DESERIALIZE_JSON_FAIL"))).await;
        }
      }
    }
  }
}