Refactor using Tauri (#278)

crates/gpapi/src/gp_params.rs

@@ -0,0 +1,153 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+use crate::GP_USER_AGENT;
+
+#[derive(Debug, Serialize, Deserialize, Clone, Type, Default)]
+pub enum ClientOs {
+  Linux,
+  #[default]
+  Windows,
+  Mac,
+}
+
+impl From<&ClientOs> for &str {
+  fn from(os: &ClientOs) -> Self {
+    match os {
+      ClientOs::Linux => "Linux",
+      ClientOs::Windows => "Windows",
+      ClientOs::Mac => "Mac",
+    }
+  }
+}
+
+impl ClientOs {
+  pub fn to_openconnect_os(&self) -> &str {
+    match self {
+      ClientOs::Linux => "linux",
+      ClientOs::Windows => "win",
+      ClientOs::Mac => "mac-intel",
+    }
+  }
+}
+
+#[derive(Debug, Serialize, Deserialize, Type, Default)]
+pub struct GpParams {
+  user_agent: String,
+  client_os: ClientOs,
+  os_version: Option<String>,
+  client_version: Option<String>,
+  computer: Option<String>,
+}
+
+impl GpParams {
+  pub fn builder() -> GpParamsBuilder {
+    GpParamsBuilder::new()
+  }
+
+  pub(crate) fn user_agent(&self) -> &str {
+    &self.user_agent
+  }
+
+  pub(crate) fn computer(&self) -> &str {
+    match self.computer {
+      Some(ref computer) => computer,
+      None => (&self.client_os).into()
+    }
+  }
+
+  pub(crate) fn to_params(&self) -> HashMap<&str, &str> {
+    let mut params: HashMap<&str, &str> = HashMap::new();
+    let client_os: &str = (&self.client_os).into();
+
+    // Common params
+    params.insert("prot", "https:");
+    params.insert("jnlpReady", "jnlpReady");
+    params.insert("ok", "Login");
+    params.insert("direct", "yes");
+    params.insert("ipv6-support", "yes");
+    params.insert("inputStr", "");
+    params.insert("clientVer", "4100");
+
+    params.insert("clientos", client_os);
+
+    if let Some(computer) = &self.computer {
+      params.insert("computer", computer);
+    } else {
+      params.insert("computer", client_os);
+    }
+
+    if let Some(os_version) = &self.os_version {
+      params.insert("os-version", os_version);
+    }
+
+    if let Some(client_version) = &self.client_version {
+      params.insert("clientgpversion", client_version);
+    }
+
+    params
+  }
+}
+
+pub struct GpParamsBuilder {
+  user_agent: String,
+  client_os: ClientOs,
+  os_version: Option<String>,
+  client_version: Option<String>,
+  computer: Option<String>,
+}
+
+impl GpParamsBuilder {
+  pub fn new() -> Self {
+    Self {
+      user_agent: GP_USER_AGENT.to_string(),
+      client_os: ClientOs::Linux,
+      os_version: Default::default(),
+      client_version: Default::default(),
+      computer: Default::default(),
+    }
+  }
+
+  pub fn user_agent(&mut self, user_agent: &str) -> &mut Self {
+    self.user_agent = user_agent.to_string();
+    self
+  }
+
+  pub fn client_os(&mut self, client_os: ClientOs) -> &mut Self {
+    self.client_os = client_os;
+    self
+  }
+
+  pub fn os_version(&mut self, os_version: &str) -> &mut Self {
+    self.os_version = Some(os_version.to_string());
+    self
+  }
+
+  pub fn client_version(&mut self, client_version: &str) -> &mut Self {
+    self.client_version = Some(client_version.to_string());
+    self
+  }
+
+  pub fn computer(&mut self, computer: &str) -> &mut Self {
+    self.computer = Some(computer.to_string());
+    self
+  }
+
+  pub fn build(&self) -> GpParams {
+    GpParams {
+      user_agent: self.user_agent.clone(),
+      client_os: self.client_os.clone(),
+      os_version: self.os_version.clone(),
+      client_version: self.client_version.clone(),
+      computer: self.computer.clone(),
+    }
+  }
+}
+
+impl Default for GpParamsBuilder {
+  fn default() -> Self {
+    Self::new()
+  }
+}