src/internal_api.rs

use crate::{core_api::IEnforcer, Result};

#[cfg(any(
    feature = "watcher",
    feature = "cached",
    feature = "logging",
    feature = "incremental"
))]
use crate::emitter::EventData;

#[cfg(any(feature = "watcher", feature = "cached", feature = "logging",))]
use crate::emitter::Event;

use async_trait::async_trait;

#[async_trait]
pub trait InternalApi: IEnforcer {
    async fn add_policy_internal(
        &mut self,
        sec: &str,
        ptype: &str,
        rule: Vec<String>,
    ) -> Result<bool>;
    async fn add_policies_internal(
        &mut self,
        sec: &str,
        ptype: &str,
        rules: Vec<Vec<String>>,
    ) -> Result<bool>;
    async fn remove_policy_internal(
        &mut self,
        sec: &str,
        ptype: &str,
        rule: Vec<String>,
    ) -> Result<bool>;
    async fn remove_policies_internal(
        &mut self,
        sec: &str,
        ptype: &str,
        rules: Vec<Vec<String>>,
    ) -> Result<bool>;
    async fn remove_filtered_policy_internal(
        &mut self,
        sec: &str,
        ptype: &str,
        field_index: usize,
        field_values: Vec<String>,
    ) -> Result<(bool, Vec<Vec<String>>)>;
}

#[async_trait]
impl<T> InternalApi for T
where
    T: IEnforcer,
{
    async fn add_policy_internal(
        &mut self,
        sec: &str,
        ptype: &str,
        rule: Vec<String>,
    ) -> Result<bool> {
        if self.has_auto_save_enabled()
            && !self
                .get_mut_adapter()
                .add_policy(sec, ptype, rule.clone())
                .await?
        {
            return Ok(false);
        }

        let rule_added = self.get_mut_model().add_policy(sec, ptype, {
            #[cfg(any(
                feature = "watcher",
                feature = "logging",
                feature = "incremental"
            ))]
            {
                rule.clone()
            }
            #[cfg(all(
                not(feature = "watcher"),
                not(feature = "logging"),
                not(feature = "incremental")
            ))]
            {
                rule
            }
        });
        #[cfg(any(feature = "watcher", feature = "logging"))]
        {
            let event_data =
                EventData::AddPolicy(sec.to_owned(), ptype.to_owned(), {
                    #[cfg(feature = "incremental")]
                    {
                        rule.clone()
                    }
                    #[cfg(not(feature = "incremental"))]
                    {
                        rule
                    }
                });
            #[cfg(feature = "watcher")]
            {
                if rule_added && self.has_auto_notify_watcher_enabled() {
                    self.emit(Event::PolicyChange, event_data);
                }
            }
            #[cfg(not(feature = "watcher"))]
            {
                if rule_added {
                    self.emit(Event::PolicyChange, event_data);
                }
            }
        }
        #[cfg(feature = "cached")]
        {
            if rule_added {
                self.emit(Event::ClearCache, EventData::ClearCache);
            }
        }
        if sec != "g" || !self.has_auto_build_role_links_enabled() {
            return Ok(rule_added);
        }
        #[cfg(not(feature = "incremental"))]
        {
            self.build_role_links()?;
        }
        #[cfg(feature = "incremental")]
        {
            self.build_incremental_role_links(EventData::AddPolicy(
                sec.to_owned(),
                ptype.to_owned(),
                rule,
            ))?;
        }

        Ok(rule_added)
    }

    async fn add_policies_internal(
        &mut self,
        sec: &str,
        ptype: &str,
        rules: Vec<Vec<String>>,
    ) -> Result<bool> {
        if self.has_auto_save_enabled()
            && !self
                .get_mut_adapter()
                .add_policies(sec, ptype, rules.clone())
                .await?
        {
            return Ok(false);
        }

        let rules_added = self.get_mut_model().add_policies(sec, ptype, {
            #[cfg(any(
                feature = "watcher",
                feature = "logging",
                feature = "incremental"
            ))]
            {
                rules.clone()
            }
            #[cfg(all(
                not(feature = "watcher"),
                not(feature = "logging"),
                not(feature = "incremental")
            ))]
            {
                rules
            }
        });
        #[cfg(any(feature = "watcher", feature = "logging"))]
        {
            let event_data =
                EventData::AddPolicies(sec.to_owned(), ptype.to_owned(), {
                    #[cfg(feature = "incremental")]
                    {
                        rules.clone()
                    }
                    #[cfg(not(feature = "incremental"))]
                    {
                        rules
                    }
                });
            #[cfg(feature = "watcher")]
            {
                if rules_added && self.has_auto_notify_watcher_enabled() {
                    self.emit(Event::PolicyChange, event_data);
                }
            }
            #[cfg(not(feature = "watcher"))]
            {
                if rules_added {
                    self.emit(Event::PolicyChange, event_data);
                }
            }
        }
        #[cfg(feature = "cached")]
        {
            if rules_added {
                self.emit(Event::ClearCache, EventData::ClearCache);
            }
        }
        if sec != "g" || !self.has_auto_build_role_links_enabled() {
            return Ok(rules_added);
        }
        #[cfg(not(feature = "incremental"))]
        {
            self.build_role_links()?;
        }
        #[cfg(feature = "incremental")]
        {
            self.build_incremental_role_links(EventData::AddPolicies(
                sec.to_owned(),
                ptype.to_owned(),
                rules,
            ))?;
        }

        Ok(rules_added)
    }

    async fn remove_policy_internal(
        &mut self,
        sec: &str,
        ptype: &str,
        rule: Vec<String>,
    ) -> Result<bool> {
        if self.has_auto_save_enabled()
            && !self
                .get_mut_adapter()
                .remove_policy(sec, ptype, rule.clone())
                .await?
        {
            return Ok(false);
        }

        let rule_removed = self.get_mut_model().remove_policy(sec, ptype, {
            #[cfg(any(
                feature = "watcher",
                feature = "logging",
                feature = "incremental"
            ))]
            {
                rule.clone()
            }
            #[cfg(all(
                not(feature = "watcher"),
                not(feature = "logging"),
                not(feature = "incremental")
            ))]
            {
                rule
            }
        });
        #[cfg(any(feature = "watcher", feature = "logging"))]
        {
            let event_data =
                EventData::RemovePolicy(sec.to_owned(), ptype.to_owned(), {
                    #[cfg(feature = "incremental")]
                    {
                        rule.clone()
                    }
                    #[cfg(not(feature = "incremental"))]
                    {
                        rule
                    }
                });
            #[cfg(feature = "watcher")]
            {
                if rule_removed && self.has_auto_notify_watcher_enabled() {
                    self.emit(Event::PolicyChange, event_data);
                }
            }
            #[cfg(not(feature = "watcher"))]
            {
                if rule_removed {
                    self.emit(Event::PolicyChange, event_data);
                }
            }
        }
        #[cfg(feature = "cached")]
        {
            if rule_removed {
                self.emit(Event::ClearCache, EventData::ClearCache);
            }
        }
        if sec != "g" || !self.has_auto_build_role_links_enabled() {
            return Ok(rule_removed);
        }
        #[cfg(not(feature = "incremental"))]
        {
            self.build_role_links()?;
        }
        #[cfg(feature = "incremental")]
        {
            self.build_incremental_role_links(EventData::RemovePolicy(
                sec.to_owned(),
                ptype.to_owned(),
                rule,
            ))?;
        }

        Ok(rule_removed)
    }

    async fn remove_policies_internal(
        &mut self,
        sec: &str,
        ptype: &str,
        rules: Vec<Vec<String>>,
    ) -> Result<bool> {
        if self.has_auto_save_enabled()
            && !self
                .get_mut_adapter()
                .remove_policies(sec, ptype, rules.clone())
                .await?
        {
            return Ok(false);
        }

        let rules_removed = self.get_mut_model().remove_policies(sec, ptype, {
            #[cfg(any(
                feature = "watcher",
                feature = "logging",
                feature = "incremental"
            ))]
            {
                rules.clone()
            }
            #[cfg(all(
                not(feature = "watcher"),
                not(feature = "logging"),
                not(feature = "incremental")
            ))]
            {
                rules
            }
        });
        #[cfg(any(feature = "watcher", feature = "logging"))]
        {
            let event_data =
                EventData::RemovePolicies(sec.to_owned(), ptype.to_owned(), {
                    #[cfg(feature = "incremental")]
                    {
                        rules.clone()
                    }
                    #[cfg(not(feature = "incremental"))]
                    {
                        rules
                    }
                });
            #[cfg(feature = "watcher")]
            {
                if rules_removed && self.has_auto_notify_watcher_enabled() {
                    self.emit(Event::PolicyChange, event_data);
                }
            }
            #[cfg(not(feature = "watcher"))]
            {
                if rules_removed {
                    self.emit(Event::PolicyChange, event_data);
                }
            }
        }
        #[cfg(feature = "cached")]
        {
            if rules_removed {
                self.emit(Event::ClearCache, EventData::ClearCache);
            }
        }
        if sec != "g" || !self.has_auto_build_role_links_enabled() {
            return Ok(rules_removed);
        }
        #[cfg(not(feature = "incremental"))]
        {
            self.build_role_links()?;
        }
        #[cfg(feature = "incremental")]
        {
            self.build_incremental_role_links(EventData::RemovePolicies(
                sec.to_owned(),
                ptype.to_owned(),
                rules,
            ))?;
        }

        Ok(rules_removed)
    }

    async fn remove_filtered_policy_internal(
        &mut self,
        sec: &str,
        ptype: &str,
        field_index: usize,
        field_values: Vec<String>,
    ) -> Result<(bool, Vec<Vec<String>>)> {
        if self.has_auto_save_enabled()
            && !self
                .get_mut_adapter()
                .remove_filtered_policy(
                    sec,
                    ptype,
                    field_index,
                    field_values.clone(),
                )
                .await?
        {
            return Ok((false, vec![]));
        }

        let (rules_removed, rules) = self
            .get_mut_model()
            .remove_filtered_policy(sec, ptype, field_index, field_values);
        #[cfg(any(feature = "watcher", feature = "logging"))]
        {
            let event_data = EventData::RemoveFilteredPolicy(
                sec.to_owned(),
                ptype.to_owned(),
                rules.clone(),
            );
            #[cfg(feature = "watcher")]
            {
                if rules_removed && self.has_auto_notify_watcher_enabled() {
                    self.emit(Event::PolicyChange, event_data);
                }
            }
            #[cfg(not(feature = "watcher"))]
            {
                if rules_removed {
                    self.emit(Event::PolicyChange, event_data);
                }
            }
        }
        #[cfg(feature = "cached")]
        {
            if rules_removed {
                self.emit(Event::ClearCache, EventData::ClearCache);
            }
        }
        if sec != "g" || !self.has_auto_build_role_links_enabled() {
            return Ok((rules_removed, rules));
        }
        #[cfg(not(feature = "incremental"))]
        {
            self.build_role_links()?;
        }
        #[cfg(feature = "incremental")]
        {
            self.build_incremental_role_links(
                EventData::RemoveFilteredPolicy(
                    sec.to_owned(),
                    ptype.to_owned(),
                    rules.clone(),
                ),
            )?;
        }

        Ok((rules_removed, rules))
    }
}