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;
        }
      }
    }
  }
}