quetty 0.1.9

Terminal-based Azure Service Bus queue manager with intuitive TUI interface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use super::operation_setup::{BulkOperationSetup, BulkOperationType, BulkOperationValidation};
use crate::app::bulk_operation_processor::BulkOperationPostProcessor;
use crate::app::model::Model;
use crate::app::task_manager::ProgressReporter;
use crate::error::AppError;
use quetty_server::bulk_operations::MessageIdentifier;
use quetty_server::service_bus_manager::{ServiceBusCommand, ServiceBusResponse};
use tuirealm::terminal::TerminalAdapter;

/// Execute bulk delete operation using simplified setup pattern
pub fn handle_bulk_delete_execution<T: TerminalAdapter>(
    model: &mut Model<T>,
    message_ids: Vec<MessageIdentifier>,
) -> Option<crate::components::common::Msg> {
    // Quick validation for empty list
    if Model::<T>::validate_not_empty(&message_ids).is_err() {
        return None;
    }

    // Use BulkOperationSetup for validation and configuration
    let validated_operation = match BulkOperationSetup::new(model, message_ids)
        .operation_type(BulkOperationType::Delete)
        .validate_and_build()
    {
        Ok(op) => op,
        Err(e) => {
            model
                .error_reporter
                .report_simple(e, "BulkDelete", "validation");
            return None;
        }
    };

    // Get pre-calculated context for post-processing
    let context = validated_operation.calculate_post_processing_context();

    let Some(service_bus_manager) = model.service_bus_manager.clone() else {
        log::warn!("Service bus manager not initialized");
        return None;
    };
    let loading_message = validated_operation.get_loading_message();
    let tx_to_main = model.tx_to_main().clone();
    let error_reporter = model.error_reporter.clone();
    let message_ids = validated_operation.message_ids().to_vec();

    let max_position = context.max_position;
    Model::<T>::log_message_order_warning(message_ids.len(), "delete");

    // Generate unique operation ID for cancellation support
    let operation_id = format!(
        "bulk_delete_{}",
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_millis()
    );

    // Use enhanced TaskManager with progress reporting and cancellation
    model.task_manager.execute_with_progress(
        loading_message,
        operation_id,
        move |progress: ProgressReporter| {
            Box::pin(async move {
                log::info!(
                    "Starting enhanced bulk delete operation for {} messages",
                    message_ids.len()
                );

                // Report initial progress
                progress.report_progress("Initializing...");

                // Execute bulk delete using service bus manager with max position
                let command = ServiceBusCommand::BulkDelete {
                    message_ids: message_ids.clone(),
                    max_position,
                };

                progress.report_progress("Executing delete operation...");

                let response = service_bus_manager
                    .lock()
                    .await
                    .execute_command(command)
                    .await;

                let delete_result = match response {
                    ServiceBusResponse::BulkOperationCompleted { result } => {
                        progress.report_progress(format!(
                            "Completed: {} successful, {} failed",
                            result.successful, result.failed
                        ));
                        result
                    }
                    ServiceBusResponse::Error { error } => {
                        log::error!("Bulk delete operation failed: {error}");
                        return Err(AppError::ServiceBus(error.to_string()));
                    }
                    _ => {
                        return Err(AppError::ServiceBus(
                            "Unexpected response for bulk delete".to_string(),
                        ));
                    }
                };

                log::info!(
                    "Bulk delete completed: {} successful, {} failed",
                    delete_result.successful,
                    delete_result.failed
                );

                progress.report_progress("Finalizing...");

                // Create context for centralized post-processing
                let message_ids_str: Vec<String> =
                    message_ids.iter().map(|id| id.to_string()).collect();
                let post_context = BulkOperationPostProcessor::create_delete_context(
                    &delete_result,
                    message_ids_str,
                    context.auto_reload_threshold,
                    context.current_message_count,
                    context.selected_from_current_page,
                );

                // Use centralized post-processor to handle completion
                BulkOperationPostProcessor::handle_completion(
                    &post_context,
                    &tx_to_main,
                    &error_reporter,
                )?;

                Ok(())
            })
        },
    );

    None
}