Method execute

atomic-cli/src/commands/team/update.rs:110–170

(&self)

impl TeamUpdate {
    async fn execute(&self) -> CliResult<()> {
        // At least one field must be provided to update.
        if self.name.is_none() && self.description.is_none() && self.visibility.is_none() {
            return Err(CliError::InvalidArgument {
                message: "At least one of --name, --description, or --visibility must be provided"
                    .to_string(),
            });
        }

        // Parse visibility if provided.
        let visibility = self
            .visibility
            .as_deref()
            .map(|v| {
                v.parse::<TeamVisibility>()
                    .map_err(|_| CliError::InvalidArgument {
                        message: format!(
                            "Invalid visibility '{}'. Valid values: visible, secret",
                            v
                        ),
                    })
            })
            .transpose()?;

        let client = build_client(self.org.as_deref(), None).await?;
        let org_slug = client.org_slug().to_string();

        let info = atomic_teams::team::update_team(
            &client,
            &org_slug,
            &self.slug,
            self.name.as_deref(),
            self.description.as_deref(),
            visibility,
        )
        .await
        .map_err(|e| CliError::RemoteError {
            message: e.to_string(),
            url: None,
        })?;

        print_success(&format!("Updated team: {}", info.slug));
        println!();

        let table = KeyValueTable::new()
            .add("Name", &info.name)
            .add("Slug", &info.slug)
            .add("Visibility", info.visibility.to_string());
        let table = if let Some(desc) = &info.description {
            table.add("Description", desc)
        } else {
            table
        };
        let table = table
            .add("Organization", &org_slug)
            .add("ID", info.id.to_string());

        println!("{table}");