darkwing/database/browser_profile/

model.rs

#![allow(
  non_snake_case,
  reason = "sqlx query_as macro does not support FromRow trait, so we cant use renamed fields. see https://github.com/launchbadge/sqlx/issues/1372 and https://github.com/launchbadge/sqlx/issues/514"
)]

use serde::Serialize;
use sqlx::types::time::OffsetDateTime;
use sqlx::types::JsonValue;
use sqlx::FromRow;

/// Represents the operating system platform for a browser profile
#[derive(Debug, Clone, PartialEq, sqlx::types::Type, Eq, Hash)]
pub enum Platform {
  /// Microsoft Windows operating system
  Windows,
  /// Apple macOS operating system
  Macos,
  /// Linux-based operating systems
  Linux,
}

impl From<String> for Platform {
  fn from(value: String) -> Self {
    match value.to_lowercase().as_str() {
      "windows" => Platform::Windows,
      "macos" => Platform::Macos,
      "linux" => Platform::Linux,
      _ => panic!("Invalid platform: {}", value),
    }
  }
}

/// Represents the type of browser being emulated
#[derive(Debug, Clone, PartialEq, sqlx::types::Type)]
pub enum BrowserType {
  /// Plain Google Chrome browser with injected scripts. Was used in the past,
  /// now not supported.
  Chrome,
  /// Mozilla Firefox browser. Not used currently.
  Firefox,
  /// Apple Safari browser. Not used currently.
  Safari,
  /// Custom Anty browser. The only supported browser type now. Used by all
  /// browser profiles.
  Anty,
}

impl From<String> for BrowserType {
  fn from(value: String) -> Self {
    match value.to_lowercase().as_str() {
      "chrome" => BrowserType::Chrome,
      "firefox" => BrowserType::Firefox,
      "safari" => BrowserType::Safari,
      _ => BrowserType::Anty,
    }
  }
}

/// Represents the main website/platform the browser profile is configured for
#[derive(Debug, Clone, PartialEq, sqlx::types::Type, Eq, Hash, Copy)]
pub enum MainWebsite {
  /// Facebook social network
  Facebook,
  /// VKontakte social network
  Vk,
  /// TikTok social media platform
  Tiktok,
  /// Google services
  Google,
  /// Cryptocurrency-related websites
  Crypto,
  /// No specific main website configured
  Empty,
}

impl MainWebsite {
  /// Returns all non-empty main websites.
  ///
  /// Used for iterating over them for checking if we have all values for
  /// corresponding main websites.
  pub const fn all() -> [Self; 5] {
    [
      Self::Facebook,
      Self::Vk,
      Self::Tiktok,
      Self::Google,
      Self::Crypto,
    ]
  }
}

impl From<String> for MainWebsite {
  fn from(value: String) -> Self {
    match value.to_lowercase().as_str() {
      "facebook" => MainWebsite::Facebook,
      "vk" => MainWebsite::Vk,
      "tiktok" => MainWebsite::Tiktok,
      "google" => MainWebsite::Google,
      "crypto" => MainWebsite::Crypto,
      _ => MainWebsite::Empty,
    }
  }
}

impl From<Option<String>> for MainWebsite {
  fn from(value: Option<String>) -> Self {
    value.map(|v| v.into()).unwrap_or(MainWebsite::Empty)
  }
}

impl From<MainWebsite> for String {
  fn from(value: MainWebsite) -> String {
    match value {
      MainWebsite::Facebook => "facebook",
      MainWebsite::Vk => "vk",
      MainWebsite::Tiktok => "tiktok",
      MainWebsite::Google => "google",
      MainWebsite::Crypto => "crypto",
      MainWebsite::Empty => "",
    }
    .into()
  }
}

impl Serialize for MainWebsite {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: serde::Serializer,
  {
    let str = String::from(*self);
    serializer.serialize_str(&str)
  }
}

/// Represents browser tabs associated with a profile
#[derive(FromRow, Debug)]
#[allow(unused)]
pub struct BrowserProfileTabs {
  /// Unique identifier for the tabs record
  pub id: u64,
  /// ID of the browser profile these tabs belong to
  pub browserProfileId: u64,
  /// JSON representation of the tabs
  pub tabs: JsonValue,
  /// When the tabs record was created
  pub created_at: Option<OffsetDateTime>,
  /// When the tabs record was last updated
  pub updated_at: Option<OffsetDateTime>,
}

/// Represents connection to the homepage for a browser profile
#[derive(FromRow, Debug)]
#[allow(unused)]
pub struct BrowserProfileHomepages {
  /// Unique identifier for the homepage record
  pub id: u64,
  /// ID of the team this homepage belongs to
  pub teamId: u64,
  /// ID of the user who created this homepage
  pub creatorId: u64,
  /// ID of the browser profile
  pub profileId: u64,
  /// ID of the homepage
  pub homepageId: u64,
  /// Order/position of the homepage
  pub order: i32,
  /// When the homepage record was created
  pub created_at: Option<OffsetDateTime>,
  /// When the homepage record was last updated
  pub updated_at: Option<OffsetDateTime>,
}

/// Represents a homepage configuration
#[derive(FromRow, Debug, Clone)]
#[allow(unused)]
pub struct Homepage {
  /// Whether this homepage is shared with the entire team
  pub sharedToEntireTeam: i8,
  /// Name of the homepage
  pub name: String,
  /// URL of the homepage
  pub url: String,
  /// Main website category this homepage belongs to
  pub mainWebsite: JsonValue,
  /// Whether this is a global homepage
  pub isGlobal: i8,
}

/// Represents a browser extension
#[derive(FromRow, Debug, Clone)]
pub struct Extension {
  /// Unique identifier for the extension
  pub extension_id: String,
  /// URL where the extension can be downloaded/accessed
  pub url: String,
  /// Display name of the extension
  pub name: Option<String>,
  /// Type of the extension
  pub r#type: String,
  /// Hash of the extension file for verification
  pub hash: Option<String>,
}

/// Represents a bookmark in the browser profile
#[derive(FromRow, Debug, Clone)]
#[allow(unused)]
pub struct Bookmark {
  /// Name of the bookmark
  pub name: String,
  /// URL of the bookmark if deleted
  pub deletedUrl: Option<String>,
  /// Main website category this bookmark belongs to
  pub mainWebsite: JsonValue,
  /// Encrypted URL of the bookmark
  pub urlCrypt: Option<Vec<u8>>,
  /// ID of the encryption key used
  pub cryptoKeyId: u32,
}

/// Represents WebGPU settings for a browser profile
#[derive(FromRow, Debug)]
#[allow(unused)]
pub struct BrowserProfileWebgpu {
  /// Unique identifier for the WebGPU configuration
  pub id: u64,
  /// ID of the browser profile this configuration belongs to
  pub browserProfileId: u64,
  /// JSON representation of WebGPU settings
  pub webgpu: JsonValue,
}

/// Represents a browser profile with fingerprint settings
#[derive(FromRow, Debug)]
#[allow(unused)]
pub struct BrowserProfileWithFingerprint {
  /// Unique identifier for the browser profile
  pub id: u64,
  /// ID of the user this profile belongs to
  #[sqlx(rename = "userId")]
  pub user_id: i64,
  /// ID of the team this profile belongs to
  #[sqlx(rename = "teamId")]
  pub team_id: i64,
  /// Name of the browser profile
  pub name: String,
  /// Main website category this profile is configured for
  #[sqlx(rename = "mainWebsite")]
  pub main_website: String,
  /// Operating system platform this profile is configured for
  pub platform: String,
  /// Type of the browser this profile is configured for
  #[sqlx(rename = "browserType")]
  pub browser_type: String,
  /// ID of the proxy this profile is configured for
  #[sqlx(rename = "proxyId")]
  pub proxy_id: i64,
  /// User-agent string for the browser profile
  pub useragent: String,
  /// WebRTC configuration for the browser profile
  pub webrtc: String,
  /// Canvas fingerprinting settings for the browser profile
  pub canvas: String,
  /// WebGL fingerprinting settings for the browser profile
  pub webgl: String,
  /// Detailed WebGL information for the browser profile
  #[sqlx(rename = "webglInfo")]
  pub webgl_info: String,
  /// Client rectangle information for the browser profile
  #[sqlx(rename = "clientRect")]
  pub client_rect: String,
  /// Notes for the browser profile
  pub notes: String,
  /// Timezone for the browser profile
  pub timezone: String,
  /// Locale for the browser profile
  pub locale: String,
  /// User-defined fields for the browser profile
  #[sqlx(rename = "userFields")]
  pub user_fields: String,
  /// Geolocation settings for the browser profile
  pub geolocation: String,
  /// Do-not-track setting for the browser profile
  #[sqlx(rename = "doNotTrack")]
  pub do_not_track: i8,
  /// Additional arguments for the browser profile
  pub args: String,
  /// CPU information for the browser profile
  pub cpu: String,
  /// Memory information for the browser profile
  pub memory: String,
  /// Screen information for the browser profile
  pub screen: String,
  /// Ports information for the browser profile
  pub ports: String,
  /// Tabs information for the browser profile
  pub tabs: String,
  /// When the browser profile was deleted
  pub deleted_at: Option<OffsetDateTime>,
  /// CPU architecture for the browser profile
  #[sqlx(rename = "cpuArchitecture")]
  pub cpu_architecture: String,
  /// Operating system version for the browser profile
  #[sqlx(rename = "osVersion")]
  pub os_version: String,
  /// Screen width for the browser profile
  #[sqlx(rename = "screenWidth")]
  pub screen_width: Option<i32>,
  /// Screen height for the browser profile
  #[sqlx(rename = "screenHeight")]
  pub screen_height: Option<i32>,
  /// Download speed for the browser profile
  #[sqlx(rename = "connectionDownlink")]
  pub connection_downlink: f64,
  /// Effective type of the connection for the browser profile
  #[sqlx(rename = "connectionEffectiveType")]
  pub connection_effective_type: String,
  /// Round-trip time for the browser profile
  #[sqlx(rename = "connectionRtt")]
  pub connection_rtt: u32,
  /// Whether data saving is enabled for the browser profile's connection
  #[sqlx(rename = "connectionSaveData")]
  pub connection_save_data: i8,
  /// The vendor sub-version string for the browser profile
  #[sqlx(rename = "vendorSub")]
  pub vendor_sub: String,
  /// The product sub-version string for the browser profile
  #[sqlx(rename = "productSub")]
  pub product_sub: String,
  /// The vendor name for the browser profile
  pub vendor: String,
  /// The product name for the browser profile
  pub product: String,
  /// The application code name for the browser profile
  #[sqlx(rename = "appCodeName")]
  pub app_code_name: String,
  /// Information about available media devices for the browser profile
  #[sqlx(rename = "mediaDevices")]
  pub media_devices: JsonValue,
  /// Hash of the data directory for the browser profile
  #[sqlx(rename = "datadirHash")]
  pub datadir_hash: Option<String>,
  /// Version of the platform for the browser profile
  #[sqlx(rename = "platformVersion")]
  pub platform_version: String,
  /// Whether the browser profile is archived (1) or not (0)
  pub archived: i8,
  /// Maximum WebGL2 capabilities for the browser profile
  #[sqlx(rename = "webgl2Maximum")]
  pub webgl2_maximum: Option<JsonValue>,
  /// Optional login credentials for the browser profile
  pub login: Option<String>,
  /// Optional password for the browser profile
  pub password: Option<String>,
  /// Optional tab configuration for the browser profile
  pub browser_profile_tabs: Option<String>,
  /// WebGPU capabilities for the browser profile
  pub webgpu: Option<JsonValue>,
  /// Whether the profile name is hidden in the UI
  #[sqlx(rename = "isHiddenProfileName")]
  pub is_hidden_profile_name: Option<bool>,
  /// When the browser profile was created
  pub created_at: OffsetDateTime,
}

/// Represents the type of proxy connection that can be used for browser
/// profiles.
///
/// Basically, Socks4 and Socks5 are the same and their only difference is
/// number in name :). We use SOCKS5 connection to SOCKS4 servers and everything
/// works OK.
#[derive(Debug, Clone)]
pub enum ProxyType {
  /// Standard HTTP proxy
  Http,
  /// HTTPS proxy with TLS encryption
  Https,
  /// SOCKS4 proxy protocol
  Socks4,
  /// SOCKS5 proxy protocol
  Socks5,
  /// SSH tunnel proxy connection
  Ssh,
}

impl From<ProxyType> for String {
  fn from(value: ProxyType) -> Self {
    match value {
      ProxyType::Http => "http".to_string(),
      ProxyType::Https => "https".to_string(),
      ProxyType::Socks4 => "socks4".to_string(),
      ProxyType::Socks5 => "socks5".to_string(),
      ProxyType::Ssh => "ssh".to_string(),
    }
  }
}

impl From<String> for ProxyType {
  fn from(value: String) -> Self {
    match value.to_lowercase().as_str() {
      "http" => ProxyType::Http,
      "https" => ProxyType::Https,
      "socks4" => ProxyType::Socks4,
      "socks5" => ProxyType::Socks5,
      "ssh" => ProxyType::Ssh,
      _ => panic!("Invalid proxy type: {}", value),
    }
  }
}

impl std::fmt::Display for ProxyType {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "{}", String::from(self.clone()))
  }
}

impl Serialize for ProxyType {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: serde::Serializer,
  {
    serializer.serialize_str(&String::from(self.clone()))
  }
}
/// Represents a proxy configuration for a browser profile
///
/// Contains both encrypted and unencrypted fields for proxy authentication and
/// connection details. The encrypted fields use a crypto key identified by
/// `cryptoKeyId` for secure storage.
#[derive(FromRow, Debug)]
#[allow(unused)]
pub struct Proxy {
  /// Unique identifier for the proxy
  pub id: u64,
  /// Type of proxy protocol (HTTP, SOCKS5, etc..)
  pub r#type: ProxyType,
  /// Hostname or IP address of the proxy server
  pub host: String,
  /// Deleted/old port value (unencrypted)
  pub deletedPort: Option<String>,
  /// Deleted/old login value (unencrypted)
  pub deletedLogin: String,
  /// Password value (unencrypted)
  pub password: String,
  /// Encrypted login credentials
  pub loginCrypt: Option<Vec<u8>>,
  /// Encrypted password
  pub passwordCrypt: Option<Vec<u8>>,
  /// Encrypted port number
  pub portCrypt: Option<Vec<u8>>,
  /// ID of the crypto key used for encryption
  pub cryptoKeyId: u32,
  /// URL for changing the proxy IP (unencrypted)
  pub changeIpUrl: Option<String>,
  /// Encrypted URL for changing the proxy IP
  pub changeIpUrlCrypt: Option<Vec<u8>>,
}

/// Represents preliminary browser profile data loaded from the database
///
/// Contains basic profile information like name and credentials, but not the
/// full profile configuration. Used as an intermediate representation for
/// local-api which uses it to prepare connection data, files, etc.
#[derive(FromRow, Debug, Clone)]
pub struct BrowserProfilePreliminary {
  /// Unique identifier for the browser profile
  pub id: u64,
  /// Timestamp when the profile was created
  pub created_at: OffsetDateTime,
  /// Display name of the profile
  pub name: String,
  /// Main website associated with this profile
  #[sqlx(rename = "mainWebsite")]
  pub main_website: String,
  /// Optional ID of the associated proxy configuration
  #[sqlx(rename = "proxyId")]
  pub proxy_id: Option<i64>,
  /// Optional login credentials for the profile
  pub login: Option<String>,
  /// Optional password for the profile
  pub password: Option<String>,
}

impl BrowserProfilePreliminary {
  /// Returns a mock `BrowserProfilePreliminary` instance.
  ///
  /// This method provides a default set of values for testing and development
  /// purposes.
  pub fn get_mock() -> Self {
    Self {
      id: 0,
      created_at: OffsetDateTime::now_utc(),
      name: "Test Profile".to_string(),
      main_website: "".to_string(),
      proxy_id: None,
      login: None,
      password: None,
    }
  }
}