tauri-plugin-sumup 0.1.3

Tauri plugin for SumUp payment processing integration on iOS and Android
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use serde::de::DeserializeOwned;
use tauri::{AppHandle, Runtime};

use crate::models::*;

#[cfg(mobile)]
use tauri::plugin::{PluginApi, PluginHandle};

#[cfg(target_os = "ios")]
tauri::ios_plugin_binding!(init_plugin_sumup);

// Mobile implementation
#[cfg(mobile)]
pub fn init<R: Runtime, C: DeserializeOwned>(
  _app: &AppHandle<R>,
  api: PluginApi<R, C>,
) -> crate::Result<Sumup<R>> {
  #[cfg(target_os = "android")]
  let handle = api.register_android_plugin("ch.manaf.tauri_plugins.sumup", "SumupPlugin")?;
  #[cfg(target_os = "ios")]
  let handle = api.register_ios_plugin(init_plugin_sumup)?;
  Ok(Sumup(handle))
}

// Desktop implementation
#[cfg(desktop)]
pub fn init<R: Runtime, C: DeserializeOwned>(
  _app: &AppHandle<R>,
  _api: tauri::plugin::PluginApi<R, C>,
) -> crate::Result<Sumup<R>> {
  Ok(Sumup(std::marker::PhantomData))
}

/// Access to the sumup APIs.
#[cfg(mobile)]
pub struct Sumup<R: Runtime>(PluginHandle<R>);

#[cfg(desktop)]
pub struct Sumup<R: Runtime>(std::marker::PhantomData<*const R>);

#[cfg(desktop)]
unsafe impl<R: Runtime> Send for Sumup<R> {}
#[cfg(desktop)]
unsafe impl<R: Runtime> Sync for Sumup<R> {}

// Mobile implementations
#[cfg(mobile)]
impl<R: Runtime> Sumup<R> {
  pub fn ping(&self, payload: PingRequest) -> crate::Result<PingResponse> {
    self
      .0
      .run_mobile_plugin("ping", payload)
      .map_err(Into::into)
  }

  pub fn init_sumup_sdk(&self, _payload: InitSdkRequest) -> crate::Result<bool> {
    self
      .0
      .run_mobile_plugin("init_sumup_sdk", _payload)
      .map_err(Into::into)
  }

  pub fn is_logged_in(&self) -> crate::Result<bool> {
    self
      .0
      .run_mobile_plugin("is_logged_in", EmptyResponse::default())
      .map_err(Into::into)
  }

  pub fn logout(&self) -> crate::Result<EmptyResponse> {
    self
      .0
      .run_mobile_plugin("logout", EmptyResponse::default())
      .map_err(Into::into)
  }

  pub fn login_with_token(&self, payload: LoginRequest) -> crate::Result<bool> {
    self
      .0
      .run_mobile_plugin("login_with_token", payload)
      .map_err(Into::into)
  }

  pub fn get_merchant(&self) -> crate::Result<MerchantInfo> {
    self
      .0
      .run_mobile_plugin("get_merchant", EmptyResponse::default())
      .map_err(Into::into)
  }

  pub fn prepare_for_checkout(&self) -> crate::Result<EmptyResponse> {
    self
      .0
      .run_mobile_plugin("prepare_for_checkout", EmptyResponse::default())
      .map_err(Into::into)
  }

  pub fn present_card_reader_selection(&self) -> crate::Result<EmptyResponse> {
    self
      .0
      .run_mobile_plugin("present_card_reader_selection", EmptyResponse::default())
      .map_err(Into::into)
  }

  pub fn checkout(&self, payload: CheckoutRequest) -> crate::Result<CheckoutResult> {
    self
      .0
      .run_mobile_plugin("checkout", payload)
      .map_err(Into::into)
  }
}

// Desktop implementations - all return UnsupportedPlatform error
#[cfg(desktop)]
impl<R: Runtime> Sumup<R> {
  pub fn ping(&self, _payload: PingRequest) -> crate::Result<PingResponse> {
    Err(crate::Error::UnsupportedPlatform)
  }

  pub fn init_sumup_sdk(&self, _payload: InitSdkRequest) -> crate::Result<bool> {
    Err(crate::Error::UnsupportedPlatform)
  }

  pub fn is_logged_in(&self) -> crate::Result<bool> {
    Err(crate::Error::UnsupportedPlatform)
  }

  pub fn logout(&self) -> crate::Result<EmptyResponse> {
    Err(crate::Error::UnsupportedPlatform)
  }

  pub fn login_with_token(&self, _payload: LoginRequest) -> crate::Result<bool> {
    Err(crate::Error::UnsupportedPlatform)
  }

  pub fn get_merchant(&self) -> crate::Result<MerchantInfo> {
    Err(crate::Error::UnsupportedPlatform)
  }

  pub fn prepare_for_checkout(&self) -> crate::Result<EmptyResponse> {
    Err(crate::Error::UnsupportedPlatform)
  }

  pub fn present_card_reader_selection(&self) -> crate::Result<EmptyResponse> {
    Err(crate::Error::UnsupportedPlatform)
  }

  pub fn checkout(&self, _payload: CheckoutRequest) -> crate::Result<CheckoutResult> {
    Err(crate::Error::UnsupportedPlatform)
  }
}