Method verify_monitor

kuma-client/src/client.rs:704–765

(self: &Arc<Self>, monitor: &Monitor)

    }

    async fn verify_monitor(self: &Arc<Self>, monitor: &Monitor) -> Result<()> {
        if let Some(referenced_parent) = monitor.common().parent() {
            if !self
                .monitors
                .lock()
                .await
                .values()
                .any(|m| m.common().id().is_some_and(|id| &id == referenced_parent))
            {
                return Err(Error::InvalidReference(
                    InvalidReferenceError::InvalidParent(referenced_parent.to_string()),
                ));
            }
        }

        if let Some(referenced_notifications) = monitor.common().notification_id_list() {
            let available_notifications = self
                .notifications
                .lock()
                .await
                .iter()
                .filter_map(|n| n.id)
                .collect::<HashSet<_>>();

            for (notification_id, _) in referenced_notifications {
                if let Some(id) = notification_id.parse::<i32>().ok() {
                    if !available_notifications.contains(&id) {
                        return Err(Error::InvalidReference(
                            InvalidReferenceError::InvalidNotification(notification_id.to_owned()),
                        ));
                    }
                } else {
                    return Err(Error::InvalidReference(
                        InvalidReferenceError::InvalidNotification(notification_id.to_owned()),
                    ));
                }
            }
        }

        if let Monitor::Docker {
            value: docker_monitor,
        } = monitor
        {
            if let Some(referenced_docker_host) = &docker_monitor.docker_host {
                if !self
                    .docker_hosts
                    .lock()
                    .await
                    .iter()
                    .any(|dh| dh.id.is_some_and(|id| &id == referenced_docker_host))
                {
                    return Err(Error::InvalidReference(
                        InvalidReferenceError::InvalidDockerHost(
                            referenced_docker_host.to_string(),
                        ),
                    ));
                }
            }