add heroledger models

heromodels/src/models/heroledger/group.rs

@@ -0,0 +1,236 @@
+use heromodels_core::{Model, BaseModelData, IndexKey};
+use heromodels_derive::model;
+use serde::{Deserialize, Serialize};
+
+/// Defines the lifecycle of a group
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum GroupStatus {
+    Active,
+    Inactive,
+    Suspended,
+    Archived,
+}
+
+impl Default for GroupStatus {
+    fn default() -> Self {
+        GroupStatus::Active
+    }
+}
+
+/// Visibility controls who can discover or view the group
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Visibility {
+    Public,   // Anyone can see and request to join
+    Private,  // Only invited users can see the group
+    Unlisted, // Not visible in search; only accessible by direct link or DNS
+}
+
+impl Default for Visibility {
+    fn default() -> Self {
+        Visibility::Public
+    }
+}
+
+/// GroupConfig holds rules that govern group membership and behavior
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct GroupConfig {
+    pub max_members: u32,
+    pub allow_guests: bool,
+    pub auto_approve: bool,
+    pub require_invite: bool,
+}
+
+impl GroupConfig {
+    pub fn new() -> Self {
+        Self {
+            max_members: 0,
+            allow_guests: false,
+            auto_approve: false,
+            require_invite: false,
+        }
+    }
+
+    pub fn max_members(mut self, max_members: u32) -> Self {
+        self.max_members = max_members;
+        self
+    }
+
+    pub fn allow_guests(mut self, allow_guests: bool) -> Self {
+        self.allow_guests = allow_guests;
+        self
+    }
+
+    pub fn auto_approve(mut self, auto_approve: bool) -> Self {
+        self.auto_approve = auto_approve;
+        self
+    }
+
+    pub fn require_invite(mut self, require_invite: bool) -> Self {
+        self.require_invite = require_invite;
+        self
+    }
+
+    pub fn build(self) -> Self {
+        self
+    }
+}
+
+/// Represents a collaborative or access-controlled unit within the system
+#[model]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct Group {
+    /// Base model data
+    pub base_data: BaseModelData,
+    #[index]
+    pub name: String,
+    pub description: String,
+    pub dnsrecords: Vec<u32>,
+    pub administrators: Vec<u32>,
+    pub config: GroupConfig,
+    pub status: GroupStatus,
+    pub visibility: Visibility,
+    pub created: u64,
+    pub updated: u64,
+}
+
+impl Group {
+    /// Create a new group instance
+    pub fn new(id: u32) -> Self {
+        let mut base_data = BaseModelData::new();
+        base_data.update_id(id);
+        Self {
+            base_data,
+            name: String::new(),
+            description: String::new(),
+            dnsrecords: Vec::new(),
+            administrators: Vec::new(),
+            config: GroupConfig::new(),
+            status: GroupStatus::default(),
+            visibility: Visibility::default(),
+            created: 0,
+            updated: 0,
+        }
+    }
+
+    /// Set the group name (fluent)
+    pub fn name(mut self, name: impl ToString) -> Self {
+        self.name = name.to_string();
+        self
+    }
+
+    /// Set the group description (fluent)
+    pub fn description(mut self, description: impl ToString) -> Self {
+        self.description = description.to_string();
+        self
+    }
+
+    /// Add a DNS record ID (fluent)
+    pub fn add_dnsrecord(mut self, dnsrecord_id: u32) -> Self {
+        self.dnsrecords.push(dnsrecord_id);
+        self
+    }
+
+    /// Set all DNS record IDs (fluent)
+    pub fn dnsrecords(mut self, dnsrecords: Vec<u32>) -> Self {
+        self.dnsrecords = dnsrecords;
+        self
+    }
+
+    /// Add an administrator user ID (fluent)
+    pub fn add_administrator(mut self, user_id: u32) -> Self {
+        self.administrators.push(user_id);
+        self
+    }
+
+    /// Set all administrator user IDs (fluent)
+    pub fn administrators(mut self, administrators: Vec<u32>) -> Self {
+        self.administrators = administrators;
+        self
+    }
+
+    /// Set the group configuration (fluent)
+    pub fn config(mut self, config: GroupConfig) -> Self {
+        self.config = config;
+        self
+    }
+
+    /// Set the group status (fluent)
+    pub fn status(mut self, status: GroupStatus) -> Self {
+        self.status = status;
+        self
+    }
+
+    /// Set the group visibility (fluent)
+    pub fn visibility(mut self, visibility: Visibility) -> Self {
+        self.visibility = visibility;
+        self
+    }
+
+    /// Set the created timestamp (fluent)
+    pub fn created(mut self, created: u64) -> Self {
+        self.created = created;
+        self
+    }
+
+    /// Set the updated timestamp (fluent)
+    pub fn updated(mut self, updated: u64) -> Self {
+        self.updated = updated;
+        self
+    }
+
+    /// Build the final group instance
+    pub fn build(self) -> Self {
+        self
+    }
+}
+
+
+
+/// Represents the membership relationship between users and groups
+#[model]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct UserGroupMembership {
+    /// Base model data
+    pub base_data: BaseModelData,
+    #[index]
+    pub user_id: u32,
+    pub group_ids: Vec<u32>,
+}
+
+impl UserGroupMembership {
+    /// Create a new user group membership instance
+    pub fn new(id: u32) -> Self {
+        let mut base_data = BaseModelData::new();
+        base_data.update_id(id);
+        Self {
+            base_data,
+            user_id: 0,
+            group_ids: Vec::new(),
+        }
+    }
+
+    /// Set the user ID (fluent)
+    pub fn user_id(mut self, user_id: u32) -> Self {
+        self.user_id = user_id;
+        self
+    }
+
+    /// Add a group ID (fluent)
+    pub fn add_group_id(mut self, group_id: u32) -> Self {
+        self.group_ids.push(group_id);
+        self
+    }
+
+    /// Set all group IDs (fluent)
+    pub fn group_ids(mut self, group_ids: Vec<u32>) -> Self {
+        self.group_ids = group_ids;
+        self
+    }
+
+    /// Build the final membership instance
+    pub fn build(self) -> Self {
+        self
+    }
+}
+
+