init projectmycelium

src/services/node_rental.rs

@@ -0,0 +1,323 @@
+//! Node rental service for managing node rentals and farmer earnings
+//! Follows the established builder pattern for consistent API design
+
+use crate::models::user::{NodeRental, NodeRentalType, NodeRentalStatus, FarmerRentalEarning, PaymentStatus, NodeAvailabilityStatus};
+use crate::services::user_persistence::{UserPersistence, ProductRental};
+use rust_decimal::Decimal;
+use chrono::{Utc, Duration};
+use std::collections::HashMap;
+
+/// Service for node rental operations
+#[derive(Clone)]
+pub struct NodeRentalService {
+    auto_billing_enabled: bool,
+    notification_enabled: bool,
+    conflict_prevention: bool,
+}
+
+/// Builder for NodeRentalService
+#[derive(Default)]
+pub struct NodeRentalServiceBuilder {
+    auto_billing_enabled: Option<bool>,
+    notification_enabled: Option<bool>,
+    conflict_prevention: Option<bool>,
+}
+
+impl NodeRentalServiceBuilder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    
+    pub fn auto_billing_enabled(mut self, enabled: bool) -> Self {
+        self.auto_billing_enabled = Some(enabled);
+        self
+    }
+    
+    pub fn notification_enabled(mut self, enabled: bool) -> Self {
+        self.notification_enabled = Some(enabled);
+        self
+    }
+    
+    pub fn conflict_prevention(mut self, enabled: bool) -> Self {
+        self.conflict_prevention = Some(enabled);
+        self
+    }
+    
+    pub fn build(self) -> Result<NodeRentalService, String> {
+        Ok(NodeRentalService {
+            auto_billing_enabled: self.auto_billing_enabled.unwrap_or(true),
+            notification_enabled: self.notification_enabled.unwrap_or(true),
+            conflict_prevention: self.conflict_prevention.unwrap_or(true),
+        })
+    }
+}
+
+impl NodeRentalService {
+    pub fn builder() -> NodeRentalServiceBuilder {
+        NodeRentalServiceBuilder::new()
+    }
+    
+    /// Rent a node product (slice or full node)
+    pub fn rent_node_product(
+        &self,
+        product_id: &str,
+        renter_email: &str,
+        duration_months: u32,
+        rental_type: NodeRentalType,
+        monthly_cost: Decimal,
+    ) -> Result<(NodeRental, FarmerRentalEarning), String> {
+        // Extract node ID from product ID
+        let node_id = if product_id.starts_with("fullnode_") {
+            product_id.strip_prefix("fullnode_").unwrap_or(product_id)
+        } else if product_id.starts_with("slice_") {
+            // For slice products, we need to find the associated node
+            // This would typically come from the product metadata
+            product_id.strip_prefix("slice_").unwrap_or(product_id)
+        } else {
+            product_id
+        };
+
+        // Check for conflicts if enabled
+        if self.conflict_prevention {
+            self.check_rental_conflicts(node_id, &rental_type)?;
+        }
+
+        // Calculate rental period
+        let start_date = Utc::now();
+        let end_date = start_date + Duration::days((duration_months * 30) as i64);
+
+        // Create rental record
+        let rental = crate::models::builders::NodeRentalBuilder::new()
+            .node_id(node_id.to_string())
+            .renter_email(renter_email.to_string())
+            .rental_type(rental_type.clone())
+            .monthly_cost(monthly_cost)
+            .start_date(start_date)
+            .end_date(end_date)
+            .status(NodeRentalStatus::Active)
+            .auto_renewal(false)
+            .payment_method("USD".to_string())
+            .build()?;
+
+        // Create farmer earning record
+        let farmer_earning = crate::models::builders::FarmerRentalEarningBuilder::new()
+            .node_id(node_id.to_string())
+            .rental_id(rental.id.clone())
+            .renter_email(renter_email.to_string())
+            .amount(monthly_cost)
+            .currency("USD".to_string())
+            .earning_date(start_date)
+            .rental_type(rental_type)
+            .payment_status(PaymentStatus::Completed)
+            .build()?;
+
+        // Find the farmer who owns this node
+        let farmer_email = self.find_node_owner(node_id)?;
+
+        // Save rental to renter's data
+        self.save_rental_to_user(&rental, renter_email, product_id)?;
+
+        // Save earning to farmer's data
+        self.save_earning_to_farmer(&farmer_earning, &farmer_email)?;
+
+        // Update node availability status
+        self.update_node_availability(node_id, &farmer_email)?;
+
+        Ok((rental, farmer_earning))
+    }
+
+    /// Check for rental conflicts
+    fn check_rental_conflicts(&self, node_id: &str, rental_type: &NodeRentalType) -> Result<(), String> {
+        // Find the farmer who owns this node
+        let farmer_email = self.find_node_owner(node_id)?;
+        
+        if let Some(farmer_data) = UserPersistence::load_user_data(&farmer_email) {
+            // Check existing rentals for this node
+            let existing_rentals: Vec<_> = farmer_data.node_rentals.iter()
+                .filter(|r| r.node_id == node_id && r.is_active())
+                .collect();
+
+            for existing_rental in existing_rentals {
+                match (&existing_rental.rental_type, rental_type) {
+                    (NodeRentalType::FullNode, _) => {
+                        return Err("Cannot rent: full node is currently rented".to_string());
+                    }
+                    (_, NodeRentalType::FullNode) => {
+                        return Err("Cannot rent full node: slices are currently rented".to_string());
+                    }
+                    (NodeRentalType::Slice, NodeRentalType::Slice) => {
+                        // Check if there's enough capacity for additional slices
+                        // This would require more complex capacity tracking
+                        // For now, we'll allow multiple slice rentals
+                    }
+                    (NodeRentalType::SliceRental, NodeRentalType::SliceRental) => {
+                        // Allow multiple slice rentals
+                    }
+                    (NodeRentalType::SliceRental, NodeRentalType::Slice) => {
+                        // Allow slice rental when slice rental exists
+                    }
+                    (NodeRentalType::Slice, NodeRentalType::SliceRental) => {
+                        // Allow slice rental when slice exists
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Find the farmer who owns a specific node
+    fn find_node_owner(&self, node_id: &str) -> Result<String, String> {
+        // Scan all user files to find the node owner
+        if let Ok(entries) = std::fs::read_dir("./user_data/") {
+            for entry in entries.flatten() {
+                if let Some(filename) = entry.file_name().to_str() {
+                    if filename.ends_with(".json")
+                        && filename.contains("_at_")
+                        && !filename.contains("_cart")
+                        && filename != "session_data.json"
+                    {
+                        let user_email = filename
+                            .trim_end_matches(".json")
+                            .replace("_at_", "@")
+                            .replace("_", ".");
+                        
+                        if let Some(user_data) = UserPersistence::load_user_data(&user_email) {
+                            if user_data.nodes.iter().any(|node| node.id == node_id) {
+                                return Ok(user_email);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+        Err(format!("Node owner not found for node: {}", node_id))
+    }
+
+    /// Save rental record to user's persistent data
+    fn save_rental_to_user(&self, rental: &NodeRental, user_email: &str, product_id: &str) -> Result<(), String> {
+        let mut user_data = UserPersistence::load_user_data(user_email)
+            .unwrap_or_else(|| self.create_default_user_data(user_email));
+
+        // Add to node rentals
+        user_data.node_rentals.push(rental.clone());
+
+        // Add to product rentals for dashboard display
+        let product_rental = ProductRental {
+            id: rental.id.clone(),
+            product_id: product_id.to_string(),
+            product_name: format!("Node Rental {}", product_id),
+            rental_type: "node".to_string(),
+            customer_email: user_email.to_string(),
+            provider_email: "unknown@provider.com".to_string(), // TODO: Get from actual provider
+            monthly_cost: rental.monthly_cost,
+            status: "Active".to_string(),
+            rental_id: rental.id.clone(),
+            start_date: rental.start_date.to_rfc3339(),
+            end_date: rental.end_date.to_rfc3339(),
+            metadata: std::collections::HashMap::new(),
+        };
+        user_data.active_product_rentals.push(product_rental);
+
+        UserPersistence::save_user_data(&user_data)
+            .map_err(|e| format!("Failed to save user data: {}", e))?;
+
+        Ok(())
+    }
+
+    /// Save earning record to farmer's persistent data
+    fn save_earning_to_farmer(&self, earning: &FarmerRentalEarning, farmer_email: &str) -> Result<(), String> {
+        let mut farmer_data = UserPersistence::load_user_data(farmer_email)
+            .unwrap_or_else(|| self.create_default_user_data(farmer_email));
+
+        // Add to farmer rental earnings
+        farmer_data.farmer_rental_earnings.push(earning.clone());
+
+        // Update wallet balance
+        farmer_data.wallet_balance_usd += earning.amount;
+
+        UserPersistence::save_user_data(&farmer_data)
+            .map_err(|e| format!("Failed to save farmer data: {}", e))?;
+
+        Ok(())
+    }
+
+    /// Update node availability status based on current rentals
+    fn update_node_availability(&self, node_id: &str, farmer_email: &str) -> Result<(), String> {
+        let mut farmer_data = UserPersistence::load_user_data(farmer_email)
+            .ok_or("Farmer data not found")?;
+
+        if let Some(node) = farmer_data.nodes.iter_mut().find(|n| n.id == node_id) {
+            // Count active rentals for this node
+            let active_rentals: Vec<_> = farmer_data.node_rentals.iter()
+                .filter(|r| r.node_id == node_id && r.is_active())
+                .collect();
+
+            node.availability_status = if active_rentals.is_empty() {
+                NodeAvailabilityStatus::Available
+            } else if active_rentals.iter().any(|r| matches!(r.rental_type, NodeRentalType::FullNode)) {
+                NodeAvailabilityStatus::FullyRented
+            } else {
+                NodeAvailabilityStatus::PartiallyRented
+            };
+
+            UserPersistence::save_user_data(&farmer_data)
+                .map_err(|e| format!("Failed to update node availability: {}", e))?;
+        }
+
+        Ok(())
+    }
+
+    /// Create default user data structure using centralized builder
+    fn create_default_user_data(&self, user_email: &str) -> crate::services::user_persistence::UserPersistentData {
+        crate::models::builders::SessionDataBuilder::new_user(user_email)
+    }
+
+    /// Get active rentals for a user
+    pub fn get_user_rentals(&self, user_email: &str) -> Vec<NodeRental> {
+        if let Some(user_data) = UserPersistence::load_user_data(user_email) {
+            user_data.node_rentals.into_iter()
+                .filter(|r| r.is_active())
+                .collect()
+        } else {
+            Vec::new()
+        }
+    }
+
+    /// Get farmer earnings from rentals
+    pub fn get_farmer_rental_earnings(&self, farmer_email: &str) -> Vec<FarmerRentalEarning> {
+        if let Some(farmer_data) = UserPersistence::load_user_data(farmer_email) {
+            farmer_data.farmer_rental_earnings
+        } else {
+            Vec::new()
+        }
+    }
+
+    /// Cancel a rental
+    pub fn cancel_rental(&self, rental_id: &str, user_email: &str) -> Result<(), String> {
+        let mut user_data = UserPersistence::load_user_data(user_email)
+            .ok_or("User data not found")?;
+
+        // Find and update the rental
+        if let Some(rental) = user_data.node_rentals.iter_mut().find(|r| r.id == rental_id) {
+            rental.status = NodeRentalStatus::Cancelled;
+            
+            // Update product rental status
+            if let Some(product_rental) = user_data.active_product_rentals.iter_mut().find(|pr| pr.id == rental_id) {
+                product_rental.status = "Cancelled".to_string();
+            }
+
+            // Update node availability
+            let farmer_email = self.find_node_owner(&rental.node_id)?;
+            self.update_node_availability(&rental.node_id, &farmer_email)?;
+
+            UserPersistence::save_user_data(&user_data)
+                .map_err(|e| format!("Failed to save user data: {}", e))?;
+
+            Ok(())
+        } else {
+            Err("Rental not found".to_string())
+        }
+    }
+}