use crate::error::BaseError;
use crate::table::{FieldType, Validator};
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct FieldConfig {
pub name: String,
pub display_name: String,
pub field_type: FieldType,
pub required: bool,
pub default_value: Option<serde_json::Value>,
pub validators: Vec<Validator>,
pub permissions: FieldPermissions,
pub filterable: bool,
pub sortable: bool,
pub relation: Option<RelationConfig>,
}
impl FieldConfig {
pub fn new(name: impl Into<String>, field_type: FieldType) -> Self {
Self {
name: name.into(),
display_name: String::new(),
field_type,
required: false,
default_value: None,
validators: Vec::new(),
permissions: FieldPermissions::default(),
filterable: true,
sortable: true,
relation: None,
}
}
pub fn display_name(mut self, name: impl Into<String>) -> Self {
self.display_name = name.into();
self
}
pub fn required(mut self, required: bool) -> Self {
self.required = required;
self
}
pub fn default_value(mut self, value: serde_json::Value) -> Self {
self.default_value = Some(value);
self
}
pub fn validator(mut self, validator: Validator) -> Self {
self.validators.push(validator);
self
}
pub fn permissions(mut self, permissions: FieldPermissions) -> Self {
self.permissions = permissions;
self
}
pub fn relation(mut self, relation: RelationConfig) -> Self {
self.relation = Some(relation);
self
}
pub fn filterable(mut self, filterable: bool) -> Self {
self.filterable = filterable;
self
}
pub fn sortable(mut self, sortable: bool) -> Self {
self.sortable = sortable;
self
}
pub fn validate(&self, value: &serde_json::Value) -> Result<(), BaseError> {
if self.required && value.is_null() {
return Err(BaseError::FieldRequired(self.name.clone()));
}
if value.is_null() {
return Ok(());
}
self.field_type.validate(&self.name, value)?;
for validator in &self.validators {
validator.validate(&self.name, value)?;
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct FieldPermissions {
pub readable_roles: HashSet<String>,
pub writable_roles: HashSet<String>,
pub filterable_roles: HashSet<String>,
pub sortable_roles: HashSet<String>,
}
impl FieldPermissions {
pub fn can_read(&self, user_roles: &HashSet<String>) -> bool {
self.readable_roles.is_empty() || user_roles.iter().any(|r| self.readable_roles.contains(r))
}
pub fn can_write(&self, user_roles: &HashSet<String>) -> bool {
self.writable_roles.is_empty() || user_roles.iter().any(|r| self.writable_roles.contains(r))
}
pub fn can_filter(&self, user_roles: &HashSet<String>) -> bool {
self.filterable_roles.is_empty()
|| user_roles.iter().any(|r| self.filterable_roles.contains(r))
}
pub fn can_sort(&self, user_roles: &HashSet<String>) -> bool {
self.sortable_roles.is_empty() || user_roles.iter().any(|r| self.sortable_roles.contains(r))
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RelationConfig {
pub table: String,
pub field: String,
pub display_fields: Vec<String>,
pub relation_type: RelationType,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum RelationType {
OneToOne,
OneToMany,
ManyToMany,
}