use super::Claims;
use serde::Serialize;
#[derive(Serialize, Debug, Clone)]
pub enum HashAlgorithmName {
#[serde(rename = "HMAC_SHA512")]
HmacSha512,
#[serde(rename = "HMAC_SHA256")]
HmacSha256,
#[serde(rename = "HMAC_SHA1")]
HmacSha1,
#[serde(rename = "HMAC_MD5")]
HmacMd5,
#[serde(rename = "SHA256")]
Sha256,
#[serde(rename = "SHA512")]
Sha512,
#[serde(rename = "PBKDF_SHA1")]
Ppkdf2Sha1,
#[serde(rename = "PBKDF_SHA256")]
Ppkdf2Sha256,
#[serde(rename = "SCRYPT")]
Scrypt,
#[serde(rename = "STANDARD_SCRYPT")]
StandardScrypt,
#[serde(rename = "BCRYPT")]
Bcrypt,
}
#[derive(Debug, Clone)]
pub enum PasswordHash {
HmacSha512 {
hash: String,
salt: Option<String>,
key: String,
},
HmacSha256 {
hash: String,
salt: Option<String>,
key: String,
},
HmacSha1 {
hash: String,
salt: Option<String>,
key: String,
},
HmacMd5 {
hash: String,
salt: Option<String>,
key: String,
},
Sha256 {
hash: String,
salt: Option<String>,
rounds: u32,
},
Sha512 {
hash: String,
salt: Option<String>,
rounds: u32,
},
Ppkdf2Sha1 {
hash: String,
salt: Option<String>,
rounds: u32,
},
Ppkdf2Sha256 {
hash: String,
salt: Option<String>,
rounds: u32,
},
Scrypt {
hash: String,
salt: Option<String>,
key: String,
rounds: u32,
memory_cost: u8,
salt_separator: Option<String>,
},
StandardScrypt {
hash: String,
salt: Option<String>,
block_size: usize,
parallelization: usize,
memory_cost: u8,
dk_len: usize,
},
Bcrypt {
hash: String,
salt: Option<String>,
},
}
#[derive(Serialize, Debug, Clone, Default)]
#[serde(rename_all = "camelCase")]
pub struct UserImportRecord {
#[serde(skip_serializing_if = "Option::is_none")]
#[serde(rename = "localId")]
pub uid: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub photo_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email_verified: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub salt: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub password_hash: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub hash_algorithm: Option<HashAlgorithmName>,
#[serde(skip_serializing_if = "Option::is_none")]
pub signer_key: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub memory_cost: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelization: Option<usize>,
#[serde(skip_serializing_if = "Option::is_none")]
pub block_size: Option<usize>,
#[serde(skip_serializing_if = "Option::is_none")]
pub dk_len: Option<usize>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rounds: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub salt_separator: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[serde(rename = "customAttributes")]
pub custom_claims: Option<Claims>,
#[serde(skip_serializing_if = "Option::is_none")]
pub disabled: Option<bool>,
}
impl UserImportRecord {
pub fn builder() -> UserImportRecordBuilder {
UserImportRecordBuilder::default()
}
}
#[derive(Clone, Default)]
pub struct UserImportRecordBuilder {
record: UserImportRecord,
}
impl UserImportRecordBuilder {
pub fn build(self) -> UserImportRecord {
self.record
}
pub fn with_uid(mut self, uid: String) -> Self {
self.record.uid = Some(uid);
self
}
pub fn with_email(mut self, email: String, verified: bool) -> Self {
self.record.email = Some(email);
self.record.email_verified = Some(verified);
self
}
pub fn with_display_name(mut self, display_name: String) -> Self {
self.record.display_name = Some(display_name);
self
}
pub fn with_photo_url(mut self, photo_url: String) -> Self {
self.record.photo_url = Some(photo_url);
self
}
pub fn with_phone_number(mut self, phone_number: String) -> Self {
self.record.phone_number = Some(phone_number);
self
}
pub fn with_custom_claims(mut self, custom_claims: Claims) -> Self {
self.record.custom_claims = Some(custom_claims);
self
}
pub fn with_being_disabled(mut self) -> Self {
self.record.disabled = Some(true);
self
}
pub fn with_password(mut self, password: PasswordHash) -> Self {
match password {
PasswordHash::HmacSha512 { hash, salt, key } => {
self.record.hash_algorithm = Some(HashAlgorithmName::HmacSha512);
self.record.password_hash = Some(hash);
self.record.salt = salt;
self.record.signer_key = Some(key);
}
PasswordHash::HmacSha256 { hash, salt, key } => {
self.record.hash_algorithm = Some(HashAlgorithmName::HmacSha256);
self.record.password_hash = Some(hash);
self.record.salt = salt;
self.record.signer_key = Some(key);
}
PasswordHash::HmacSha1 { hash, salt, key } => {
self.record.hash_algorithm = Some(HashAlgorithmName::HmacSha1);
self.record.password_hash = Some(hash);
self.record.salt = salt;
self.record.signer_key = Some(key);
}
PasswordHash::HmacMd5 { hash, salt, key } => {
self.record.hash_algorithm = Some(HashAlgorithmName::HmacMd5);
self.record.password_hash = Some(hash);
self.record.salt = salt;
self.record.signer_key = Some(key);
}
PasswordHash::Sha256 { hash, salt, rounds } => {
self.record.hash_algorithm = Some(HashAlgorithmName::Sha256);
self.record.password_hash = Some(hash);
self.record.salt = salt;
self.record.rounds = Some(rounds);
}
PasswordHash::Sha512 { hash, salt, rounds } => {
self.record.hash_algorithm = Some(HashAlgorithmName::Sha512);
self.record.password_hash = Some(hash);
self.record.salt = salt;
self.record.rounds = Some(rounds);
}
PasswordHash::Ppkdf2Sha1 { hash, salt, rounds } => {
self.record.hash_algorithm = Some(HashAlgorithmName::Ppkdf2Sha1);
self.record.password_hash = Some(hash);
self.record.salt = salt;
self.record.rounds = Some(rounds);
}
PasswordHash::Ppkdf2Sha256 { hash, salt, rounds } => {
self.record.hash_algorithm = Some(HashAlgorithmName::Ppkdf2Sha256);
self.record.password_hash = Some(hash);
self.record.salt = salt;
self.record.rounds = Some(rounds);
}
PasswordHash::Scrypt {
hash,
salt,
rounds,
key,
memory_cost,
salt_separator,
} => {
self.record.hash_algorithm = Some(HashAlgorithmName::Scrypt);
self.record.password_hash = Some(hash);
self.record.salt = salt;
self.record.rounds = Some(rounds);
self.record.signer_key = Some(key);
self.record.memory_cost = Some(memory_cost);
self.record.salt_separator = salt_separator;
}
PasswordHash::StandardScrypt {
hash,
salt,
memory_cost,
block_size,
parallelization,
dk_len,
} => {
self.record.hash_algorithm = Some(HashAlgorithmName::StandardScrypt);
self.record.password_hash = Some(hash);
self.record.salt = salt;
self.record.memory_cost = Some(memory_cost);
self.record.block_size = Some(block_size);
self.record.parallelization = Some(parallelization);
self.record.dk_len = Some(dk_len);
}
PasswordHash::Bcrypt { hash, salt } => {
self.record.hash_algorithm = Some(HashAlgorithmName::Bcrypt);
self.record.password_hash = Some(hash);
self.record.salt = salt;
}
}
self
}
}
#[derive(Serialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct UserImportRecords {
pub users: Vec<UserImportRecord>,
}