feat: implement common types module (#212)

contracts/Cargo.toml

@@ -3,11 +3,13 @@ resolver = "2"
 members = [
     "access_control",
     "manage_hub",
-    "membership_token"
+    "membership_token",
+    "common_types"
 ]
 
 [workspace.dependencies]
 soroban-sdk = "22.0.0"
+common_types = { path = "common_types" }
 
 [profile.release]
 opt-level = "z"
@@ -22,4 +24,4 @@ lto = true
 # For more information about this profile see https://soroban.stellar.org/docs/basic-tutorials/logging#cargotoml-profile
 [profile.release-with-logs]
 inherits = "release"
-debug-assertions = true
+debug-assertions = true

contracts/common_types/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "common_types"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+soroban-sdk = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }

contracts/common_types/src/lib.rs

@@ -0,0 +1,14 @@
+#![no_std]
+
+//! Common types for ManageHub contracts.
+//!
+//! This crate provides shared enums and structs to ensure consistency
+//! across all ManageHub smart contracts.
+
+mod types;
+
+// Re-export all types
+pub use types::{AttendanceAction, MembershipStatus, SubscriptionPlan, UserRole};
+
+#[cfg(test)]
+mod test_contract;

contracts/common_types/src/test_contract.rs

@@ -0,0 +1,115 @@
+//! Test contract to verify common types functionality
+
+use crate::{AttendanceAction, MembershipStatus, SubscriptionPlan, UserRole};
+use soroban_sdk::{contract, contractimpl, Env, Symbol};
+
+#[contract]
+pub struct TestTypesContract;
+
+#[contractimpl]
+impl TestTypesContract {
+    pub fn test_subscription(plan: SubscriptionPlan) -> SubscriptionPlan {
+        plan
+    }
+
+    pub fn test_attendance(action: AttendanceAction) -> AttendanceAction {
+        action
+    }
+
+    pub fn test_role(role: UserRole) -> UserRole {
+        role
+    }
+
+    pub fn test_status(status: MembershipStatus) -> MembershipStatus {
+        status
+    }
+
+    pub fn test_all_types(
+        _env: Env,
+        plan: SubscriptionPlan,
+        action: AttendanceAction,
+        role: UserRole,
+        status: MembershipStatus,
+    ) -> Symbol {
+        let _subscription = plan;
+        let _attendance = action;
+        let _user_role = role;
+        let _membership = status;
+        Symbol::new(&_env, "success")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_subscription_plan() {
+        let env = Env::default();
+        let contract_id = env.register(TestTypesContract, ());
+        let client = TestTypesContractClient::new(&env, &contract_id);
+
+        assert_eq!(
+            client.test_subscription(&SubscriptionPlan::Monthly),
+            SubscriptionPlan::Monthly
+        );
+        assert_eq!(
+            client.test_subscription(&SubscriptionPlan::Daily),
+            SubscriptionPlan::Daily
+        );
+    }
+
+    #[test]
+    fn test_attendance() {
+        let env = Env::default();
+        let contract_id = env.register(TestTypesContract, ());
+        let client = TestTypesContractClient::new(&env, &contract_id);
+
+        assert_eq!(
+            client.test_attendance(&AttendanceAction::ClockIn),
+            AttendanceAction::ClockIn
+        );
+    }
+
+    #[test]
+    fn test_role() {
+        let env = Env::default();
+        let contract_id = env.register(TestTypesContract, ());
+        let client = TestTypesContractClient::new(&env, &contract_id);
+
+        assert_eq!(client.test_role(&UserRole::Admin), UserRole::Admin);
+    }
+
+    #[test]
+    fn test_status() {
+        let env = Env::default();
+        let contract_id = env.register(TestTypesContract, ());
+        let client = TestTypesContractClient::new(&env, &contract_id);
+
+        assert_eq!(
+            client.test_status(&MembershipStatus::Active),
+            MembershipStatus::Active
+        );
+        assert_eq!(
+            client.test_status(&MembershipStatus::Revoked),
+            MembershipStatus::Revoked
+        );
+    }
+
+    #[test]
+    fn test_all_types() {
+        let env = Env::default();
+        let contract_id = env.register(TestTypesContract, ());
+
+        let client = TestTypesContractClient::new(&env, &contract_id);
+
+        let result = client.test_all_types(
+            &SubscriptionPlan::PayPerUse,
+            &AttendanceAction::ClockOut,
+            &UserRole::Staff,
+            &MembershipStatus::Active,
+        );
+
+        assert_eq!(result, Symbol::new(&env, "success"));
+    }
+}

contracts/common_types/src/types.rs

@@ -0,0 +1,147 @@
+//! Common types used across ManageHub contracts.
+//!
+//! This module provides shared enums and structs to ensure consistency
+//! across all ManageHub smart contracts, including subscription management,
+//! attendance tracking, and user role definitions.
+
+use soroban_sdk::contracttype;
+
+/// Subscription plan types available in ManageHub.
+///
+/// Defines the different billing frequencies for subscriptions.
+///
+/// # Variants
+/// * `Daily` - Daily subscription billing
+/// * `Monthly` - Monthly subscription billing
+/// * `PayPerUse` - Pay-as-you-go billing model
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum SubscriptionPlan {
+    /// Daily subscription plan
+    Daily,
+    /// Monthly subscription plan
+    Monthly,
+    /// Pay-per-use plan
+    PayPerUse,
+}
+
+/// Attendance tracking actions.
+///
+/// Represents the possible attendance actions that can be recorded
+/// in the system.
+///
+/// # Variants
+/// * `ClockIn` - User clocks in (arrival)
+/// * `ClockOut` - User clocks out (departure)
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum AttendanceAction {
+    /// Clock in action (arrival)
+    ClockIn,
+    /// Clock out action (departure)
+    ClockOut,
+}
+
+/// User role types in the ManageHub system.
+///
+/// Defines the different permission levels and user types
+/// within the platform.
+///
+/// # Variants
+/// * `Member` - Regular member with standard access
+/// * `Staff` - Staff member with elevated privileges
+/// * `Admin` - Administrator with full access
+/// * `Visitor` - Temporary visitor with limited access
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum UserRole {
+    /// Regular member
+    Member,
+    /// Staff member with elevated privileges
+    Staff,
+    /// Administrator with full access
+    Admin,
+    /// Temporary visitor with limited access
+    Visitor,
+}
+
+/// Membership status types.
+///
+/// Tracks the current state of a user's membership.
+/// Includes all status variants used across ManageHub contracts.
+///
+/// # Variants
+/// * `Active` - Membership is currently active
+/// * `Expired` - Membership has expired
+/// * `Revoked` - Membership has been revoked
+/// * `Inactive` - Membership is inactive
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum MembershipStatus {
+    /// Active membership
+    Active,
+    /// Expired membership
+    Expired,
+    /// Revoked membership
+    Revoked,
+    /// Inactive membership
+    Inactive,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_subscription_plan_variants() {
+        let daily = SubscriptionPlan::Daily;
+        let monthly = SubscriptionPlan::Monthly;
+        let pay_per_use = SubscriptionPlan::PayPerUse;
+
+        assert_eq!(daily, SubscriptionPlan::Daily);
+        assert_eq!(monthly, SubscriptionPlan::Monthly);
+        assert_eq!(pay_per_use, SubscriptionPlan::PayPerUse);
+    }
+
+    #[test]
+    fn test_attendance_action_variants() {
+        let clock_in = AttendanceAction::ClockIn;
+        let clock_out = AttendanceAction::ClockOut;
+
+        assert_eq!(clock_in, AttendanceAction::ClockIn);
+        assert_eq!(clock_out, AttendanceAction::ClockOut);
+    }
+
+    #[test]
+    fn test_user_role_variants() {
+        let member = UserRole::Member;
+        let staff = UserRole::Staff;
+        let admin = UserRole::Admin;
+        let visitor = UserRole::Visitor;
+
+        assert_eq!(member, UserRole::Member);
+        assert_eq!(staff, UserRole::Staff);
+        assert_eq!(admin, UserRole::Admin);
+        assert_eq!(visitor, UserRole::Visitor);
+    }
+
+    #[test]
+    fn test_membership_status_variants() {
+        let active = MembershipStatus::Active;
+        let expired = MembershipStatus::Expired;
+        let revoked = MembershipStatus::Revoked;
+        let inactive = MembershipStatus::Inactive;
+
+        assert_eq!(active, MembershipStatus::Active);
+        assert_eq!(expired, MembershipStatus::Expired);
+        assert_eq!(revoked, MembershipStatus::Revoked);
+        assert_eq!(inactive, MembershipStatus::Inactive);
+    }
+
+    #[test]
+    fn test_clone_derive() {
+        let plan = SubscriptionPlan::Monthly;
+        let cloned = plan.clone();
+        assert_eq!(plan, cloned);
+    }
+}