use crate::AxiamError;
use crate::management::error::local_refusal;
use crate::management::models;
pub(crate) fn parse_sp_metadata_exactly_one(
body: &models::ParseSamlSpMetadata,
) -> Result<(), AxiamError> {
match (&body.metadata_xml, &body.metadata_url) {
(Some(_), None) | (None, Some(_)) => Ok(()),
(Some(_), Some(_)) => Err(local_refusal(
"saml.parse_sp_metadata",
"metadata_xml",
"set exactly one of metadata_xml and metadata_url, not both (CONTRACT.md §29.2)",
)),
(None, None) => Err(local_refusal(
"saml.parse_sp_metadata",
"metadata_url",
"set exactly one of metadata_xml and metadata_url (CONTRACT.md §29.2)",
)),
}
}
impl models::ParseSamlSpMetadata {
pub fn from_url(url: impl Into<String>) -> Self {
Self {
metadata_url: Some(url.into()),
metadata_xml: None,
}
}
pub fn from_xml(xml: impl Into<String>) -> Self {
Self {
metadata_url: None,
metadata_xml: Some(xml.into()),
}
}
}
impl From<&models::SamlServiceProvider> for models::SamlServiceProviderInput {
fn from(sp: &models::SamlServiceProvider) -> Self {
Self {
acs_urls: sp.acs_urls.clone(),
allow_idp_initiated: Some(sp.allow_idp_initiated),
allowed_groups: Some(sp.allowed_groups.clone()),
attribute_mappings: Some(sp.attribute_mappings.clone()),
display_name: sp.display_name.clone(),
enabled: Some(sp.enabled),
encrypt_assertions: Some(sp.encrypt_assertions),
entity_id: sp.entity_id.clone(),
name_id_format: Some(sp.name_id_format.clone()),
sign_responses: Some(sp.sign_responses),
slo_binding: sp.slo_binding.clone(),
slo_url: sp.slo_url.clone(),
sp_encryption_cert_pem: sp.sp_encryption_cert_pem.clone(),
sp_signing_cert_pem: sp.sp_signing_cert_pem.clone(),
want_authn_requests_signed: Some(sp.want_authn_requests_signed),
}
}
}
pub(crate) fn explicit_null<'de, D, T>(deserializer: D) -> Result<Option<Option<T>>, D::Error>
where
D: serde::Deserializer<'de>,
T: serde::Deserialize<'de>,
{
serde::Deserialize::deserialize(deserializer).map(Some)
}
impl From<&models::SsfStream> for models::SsfStreamInput {
fn from(s: &models::SsfStream) -> Self {
Self {
audience: s.audience.clone(),
authorization_header: None,
clear_authorization_header: None,
delivery_method: s.delivery_method.clone(),
description: s.description.clone(),
endpoint_url: s.endpoint_url.clone(),
events_allowed: s.events_allowed.clone(),
events_requested: Some(s.events_requested.clone()),
expected_updated_at: Some(s.updated_at.clone()),
receiver_client_id: s.receiver_client_id.clone(),
status: Some(s.status.clone()),
status_reason: s.status_reason.clone(),
subject_format: Some(s.subject_format.clone()),
}
}
}
#[derive(Debug, Clone, Default)]
pub struct SsfStreamChanges {
pub audience: Option<String>,
pub authorization_header: Option<crate::Sensitive<String>>,
pub clear_authorization_header: Option<bool>,
pub delivery_method: Option<models::SsfDeliveryMethod>,
pub description: Option<Option<String>>,
pub endpoint_url: Option<Option<String>>,
pub events_allowed: Option<Vec<models::SsfEventType>>,
pub events_requested: Option<Option<Vec<models::SsfEventType>>>,
pub expected_updated_at: Option<Option<String>>,
pub receiver_client_id: Option<String>,
pub status: Option<models::SsfStreamStatus>,
pub status_reason: Option<Option<String>>,
pub subject_format: Option<models::SsfSubjectFormat>,
}
impl models::SsfStreamInput {
#[must_use]
pub fn from_stream_with(stream: &models::SsfStream, changes: SsfStreamChanges) -> Self {
let mut body = Self::from(stream);
let SsfStreamChanges {
audience,
authorization_header,
clear_authorization_header,
delivery_method,
description,
endpoint_url,
events_allowed,
events_requested,
expected_updated_at,
receiver_client_id,
status,
status_reason,
subject_format,
} = changes;
if let Some(v) = audience {
body.audience = v;
}
if let Some(v) = authorization_header {
body.authorization_header = Some(v);
}
if let Some(v) = clear_authorization_header {
body.clear_authorization_header = Some(v);
}
if let Some(v) = delivery_method {
body.delivery_method = v;
}
if let Some(v) = description {
body.description = v;
}
if let Some(v) = endpoint_url {
body.endpoint_url = v;
}
if let Some(ceiling) = events_allowed {
if events_requested.is_none() {
body.events_requested = body.events_requested.take().map(|read| {
read.into_iter()
.filter(|event| ceiling.contains(event))
.collect()
});
}
body.events_allowed = ceiling;
}
if let Some(v) = events_requested {
body.events_requested = v;
}
if let Some(v) = expected_updated_at {
body.expected_updated_at = v;
}
if let Some(v) = receiver_client_id {
body.receiver_client_id = v;
}
if let Some(v) = status {
body.status = Some(v);
}
if let Some(v) = status_reason {
body.status_reason = v;
}
if let Some(v) = subject_format {
body.subject_format = Some(v);
}
body
}
}
impl From<&models::ScimTargetResponse> for models::ScimTargetInput {
fn from(t: &models::ScimTargetResponse) -> Self {
Self {
auth: t.auth.clone(),
base_url: t.base_url.clone(),
credential: None,
deprovision: Some(t.deprovision.clone()),
enabled: Some(t.enabled),
expected_updated_at: Some(t.updated_at.clone()),
name: t.name.clone(),
push_groups: Some(t.push_groups),
scope: t.scope.clone(),
user_name_from: Some(t.user_name_from.clone()),
}
}
}
impl From<&models::DirectoryConfig> for models::SetDirectoryConfig {
fn from(c: &models::DirectoryConfig) -> Self {
Self {
base_dn: c.base_dn.clone(),
bind_dn: c.bind_dn.clone(),
bind_secret: None,
enabled: c.enabled,
group_base_dn: c.group_base_dn.clone(),
group_filter: c.group_filter.clone(),
group_mappings: Some(c.group_mappings.clone()),
group_member_attribute: Some(c.group_member_attribute.clone()),
group_nesting_depth: Some(c.group_nesting_depth),
jit_provisioning: Some(c.jit_provisioning),
kind: c.kind.clone(),
start_tls: c.start_tls,
sync_interval_secs: Some(c.sync_interval_secs),
trust_anchors_pem: Some(c.trust_anchors_pem.clone()),
url: c.url.clone(),
user_attribute_map: Some(c.user_attribute_map.clone()),
user_filter: c.user_filter.clone(),
}
}
}