raps-cli 4.15.0

RAPS (rapeseed) - Rust Autodesk Platform Services CLI
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

// SPDX-License-Identifier: Apache-2.0
// Copyright 2024-2025 Dmytro Yemelianov

//! Folder permission management command implementations

use std::sync::Arc;

use anyhow::Result;
use colored::Colorize;

use raps_acc::admin::AccountAdminClient;
use raps_admin::BulkConfig;
use raps_kernel::auth::AuthClient;
use raps_kernel::config::Config;
use raps_kernel::http::HttpClientConfig;

use crate::output::OutputFormat;

use super::operations::display_bulk_result;
use super::{
    FolderCommands, create_bulk_progress_bar, get_account_id, make_progress_callback,
    parse_filter_with_ids,
};

impl FolderCommands {
    pub async fn execute(
        self,
        config: &Config,
        auth_client: &AuthClient,
        output_format: OutputFormat,
    ) -> Result<()> {
        match self {
            FolderCommands::Rights {
                email,
                account,
                level,
                folder,
                filter,
                project_ids,
                concurrency,
                dry_run,
                yes: _,
            } => {
                let account_id = get_account_id(account)?;
                let project_filter = parse_filter_with_ids(&filter, &project_ids)?;

                // Parse folder type
                let folder_type = match folder.to_lowercase().as_str() {
                    "project-files" | "projectfiles" => raps_admin::FolderType::ProjectFiles,
                    "plans" => raps_admin::FolderType::Plans,
                    _ => raps_admin::FolderType::Custom(folder.clone()),
                };

                // Create bulk config
                let bulk_config = BulkConfig {
                    concurrency: concurrency.min(50),
                    dry_run,
                    ..Default::default()
                };

                if output_format.supports_colors() {
                    println!(
                        "\n{} Bulk update folder rights for: {} in account {}",
                        "\u{2192}".cyan(),
                        email.green(),
                        account_id.cyan()
                    );
                    println!("  Folder: {}", folder);
                    println!("  Permission level: {:?}", level);
                    if let Some(f) = &filter {
                        println!("  Filter: {}", f);
                    }
                    println!("  Concurrency: {}", concurrency.min(50));
                    if dry_run {
                        println!("  {} Dry-run mode enabled", "\u{26A0}".yellow());
                    }
                    println!();
                }

                // Create API clients
                let http_config = HttpClientConfig::default();
                let admin_client = AccountAdminClient::new_with_http_config(
                    config.clone(),
                    auth_client.clone(),
                    http_config.clone(),
                );
                let permissions_client = Arc::new(
                    raps_acc::permissions::FolderPermissionsClient::new_with_http_config(
                        config.clone(),
                        auth_client.clone(),
                        http_config,
                    ),
                );

                let progress_bar = create_bulk_progress_bar(output_format);
                let on_progress = make_progress_callback(progress_bar.clone());

                // Execute bulk operation
                let result = raps_admin::bulk_update_folder_rights(
                    &admin_client,
                    permissions_client,
                    &account_id,
                    &email,
                    level.into(),
                    folder_type,
                    &project_filter,
                    bulk_config,
                    on_progress,
                )
                .await?;

                // Finish progress bar
                if let Some(pb) = progress_bar {
                    pb.finish_and_clear();
                }

                // Display results
                display_bulk_result(&result, output_format)?;

                // Exit with appropriate code
                if result.failed > 0 {
                    anyhow::bail!(
                        "Bulk operation partially failed: {} items failed",
                        result.failed
                    );
                }

                Ok(())
            }
        }
    }
}