qleany-common 1.8.0

// Generated by Qleany v1.7.0 from common_entities.tera

use crate::types::EntityId;
use crate::types::HasId;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct Root {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub workspace: Option<EntityId>,
    pub system: Option<EntityId>,
}

impl HasId for Root {
    fn id(&self) -> EntityId {
        self.id
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct Workspace {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub manifest_absolute_path: String,
    pub global: EntityId,
    pub entities: Vec<EntityId>,
    pub features: Vec<EntityId>,
    pub user_interface: EntityId,
}

impl HasId for Workspace {
    fn id(&self) -> EntityId {
        self.id
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct System {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub version: String,
    pub files: Vec<EntityId>,
}

impl HasId for System {
    fn id(&self) -> EntityId {
        self.id
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct Entity {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub name: String,
    pub inherits_from: Option<EntityId>,
    pub only_for_heritage: bool,
    pub fields: Vec<EntityId>,
    pub relationships: Vec<EntityId>,
    pub single_model: bool,
    pub undoable: bool,
}

impl HasId for Entity {
    fn id(&self) -> EntityId {
        self.id
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct Field {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub name: String,
    pub field_type: FieldType,
    pub entity: Option<EntityId>,
    pub relationship: FieldRelationshipType,
    pub optional: bool,
    pub is_list: bool,
    pub strong: bool,
    pub list_model: bool,
    pub list_model_displayed_field: Option<String>,
    pub enum_name: Option<String>,
    pub enum_values: Vec<String>,
}

impl HasId for Field {
    fn id(&self) -> EntityId {
        self.id
    }
}
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
pub enum FieldType {
    #[default]
    Boolean,
    Integer,
    UInteger,
    Float,
    String,
    Uuid,
    DateTime,
    Entity,
    Enum,
}
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
pub enum FieldRelationshipType {
    #[default]
    OneToOne,
    ManyToOne,
    OrderedOneToMany,
    OneToMany,
    ManyToMany,
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct Feature {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub name: String,
    pub use_cases: Vec<EntityId>,
}

impl HasId for Feature {
    fn id(&self) -> EntityId {
        self.id
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct File {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub name: String,
    pub relative_path: String,
    pub group: String,
    pub template_name: String,
    pub generated_code: Option<String>,
    pub status: FileStatus,
    pub nature: FileNature,
    pub feature: Option<EntityId>,
    pub all_features: bool,
    pub entity: Option<EntityId>,
    pub all_entities: bool,
    pub use_case: Option<EntityId>,
    pub all_use_cases: bool,
    pub field: Option<EntityId>,
}

impl HasId for File {
    fn id(&self) -> EntityId {
        self.id
    }
}
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
pub enum FileStatus {
    #[default]
    Unknown,
    Unchanged,
    Modified,
    New,
}
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
pub enum FileNature {
    #[default]
    Infrastructure,
    Aggregate,
    Scaffold,
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct UseCase {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub name: String,
    pub entities: Vec<EntityId>,
    pub undoable: bool,
    pub read_only: bool,
    pub long_operation: bool,
    pub dto_in: Option<EntityId>,
    pub dto_out: Option<EntityId>,
}

impl HasId for UseCase {
    fn id(&self) -> EntityId {
        self.id
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct Dto {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub name: String,
    pub fields: Vec<EntityId>,
}

impl HasId for Dto {
    fn id(&self) -> EntityId {
        self.id
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct DtoField {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub name: String,
    pub field_type: DtoFieldType,
    pub optional: bool,
    pub is_list: bool,
    pub enum_name: Option<String>,
    pub enum_values: Vec<String>,
}

impl HasId for DtoField {
    fn id(&self) -> EntityId {
        self.id
    }
}
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
pub enum DtoFieldType {
    #[default]
    Boolean,
    Integer,
    UInteger,
    Float,
    String,
    Uuid,
    DateTime,
    Enum,
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct Global {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub language: String,
    pub application_name: String,
    pub organisation_name: String,
    pub organisation_domain: String,
    pub prefix_path: String,
}

impl HasId for Global {
    fn id(&self) -> EntityId {
        self.id
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct Relationship {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub left_entity: Option<EntityId>,
    pub right_entity: Option<EntityId>,
    pub field_name: String,
    pub relationship_type: RelationshipType,
    pub strength: Strength,
    pub direction: Direction,
    pub cardinality: Cardinality,
    pub order: Option<Order>,
}

impl HasId for Relationship {
    fn id(&self) -> EntityId {
        self.id
    }
}
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
pub enum RelationshipType {
    #[default]
    OneToOne,
    ManyToOne,
    OneToMany,
    OrderedOneToMany,
    ManyToMany,
}
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
pub enum Strength {
    #[default]
    Weak,
    Strong,
}
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
pub enum Direction {
    #[default]
    Forward,
    Backward,
}
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
pub enum Cardinality {
    #[default]
    ZeroOrOne,
    One,
    ZeroOrMore,
    OneOrMore,
}
#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
pub enum Order {
    #[default]
    Ordered,
    Unordered,
}

#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct UserInterface {
    pub id: EntityId,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(with = "chrono::serde::ts_milliseconds")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub rust_cli: bool,
    pub rust_slint: bool,
    pub cpp_qt_qtwidgets: bool,
    pub cpp_qt_qtquick: bool,
    pub rust_ios: bool,
    pub rust_android: bool,
}

impl HasId for UserInterface {
    fn id(&self) -> EntityId {
        self.id
    }
}