Add command to get organizations using v4 endpoint

src/cli/cloud_json.rs

@@ -43,6 +43,32 @@ impl JSONCloudClustersSummariesV3 {
     }
 }
 
+#[derive(Debug, Deserialize)]
+pub(crate) struct JSONCloudsOrganizationsResponse {
+    data: Vec<JSONCloudsOrganizationsResponseItem>,
+}
+
+impl JSONCloudsOrganizationsResponse {
+    pub fn items(&self) -> &Vec<JSONCloudsOrganizationsResponseItem> {
+        self.data.as_ref()
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct JSONCloudsOrganizationsResponseItem {
+    id: String,
+    name: String,
+}
+
+impl JSONCloudsOrganizationsResponseItem {
+    pub fn id(&self) -> &str {
+        &self.id
+    }
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+}
+
 #[derive(Debug, Deserialize)]
 pub(crate) struct JSONCloudsProjectsResponseItem {
     id: String,

src/cli/mod.rs

@@ -36,6 +36,7 @@
 mod health;
 mod help;
 mod nodes;
+mod organizations;
 mod ping;
 // mod plugin_from_bson;
 mod cbenv_bucket;
@@ -111,6 +112,7 @@
 pub use health::HealthCheck;
 pub use help::Help;
 pub use nodes::Nodes;
+pub use organizations::Organizations;
 pub use ping::Ping;
 // pub use plugin_from_bson::PluginFromBson;
 pub use cbenv_bucket::UseBucket;
@@ -138,7 +140,7 @@
 pub use tutorial_next::TutorialNext;
 pub use tutorial_page::TutorialPage;
 pub use tutorial_prev::TutorialPrev;
 pub use user_builder::User;
 pub use users::Users;
 pub use users_drop::UsersDrop;
 pub use users_get::UsersGet;

src/cli/organizations.rs

@@ -0,0 +1,99 @@
+use crate::cli::cloud_json::JSONCloudsOrganizationsResponse;
+use crate::cli::util::NuValueMap;
+use crate::client::CapellaRequest;
+use crate::state::State;
+use std::sync::{Arc, Mutex};
+
+use log::debug;
+use std::ops::Add;
+use tokio::time::Instant;
+
+use crate::cli::error::{
+    client_error_to_shell_error, deserialize_error, unexpected_status_code_error,
+};
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, IntoPipelineData, PipelineData, ShellError, Signature, Value};
+
+#[derive(Clone)]
+pub struct Organizations {
+    state: Arc<Mutex<State>>,
+}
+
+impl Organizations {
+    pub fn new(state: Arc<Mutex<State>>) -> Self {
+        Self { state }
+    }
+}
+
+impl Command for Organizations {
+    fn name(&self) -> &str {
+        "organizations"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("organizations").category(Category::Custom("couchbase".to_string()))
+    }
+
+    fn usage(&self) -> &str {
+        "Lists all organizations the user has access too"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        organizations(self.state.clone(), engine_state, stack, call, input)
+    }
+}
+
+fn organizations(
+    state: Arc<Mutex<State>>,
+    engine_state: &EngineState,
+    _stack: &mut Stack,
+    call: &Call,
+    _input: PipelineData,
+) -> Result<PipelineData, ShellError> {
+    let span = call.head;
+    let ctrl_c = engine_state.ctrlc.as_ref().unwrap().clone();
+
+    debug!("Running organizations");
+
+    let guard = state.lock().unwrap();
+    let control = guard.active_capella_org()?;
+    let client = control.client();
+    let response = client
+        .capella_request(
+            CapellaRequest::GetOrganizations {},
+            Instant::now().add(control.timeout()),
+            ctrl_c,
+        )
+        .map_err(|e| client_error_to_shell_error(e, span))?;
+    if response.status() != 200 {
+        return Err(unexpected_status_code_error(
+            response.status(),
+            response.content(),
+            span,
+        ));
+    }
+
+    let content: JSONCloudsOrganizationsResponse = serde_json::from_str(response.content())
+        .map_err(|e| deserialize_error(e.to_string(), span))?;
+
+    let mut results = vec![];
+    for project in content.items() {
+        let mut collected = NuValueMap::default();
+        collected.add_string("name", project.name(), span);
+        collected.add_string("id", project.id(), span);
+        results.push(collected.into_value(span))
+    }
+
+    Ok(Value::List {
+        vals: results,
+        span: span,
+    }
+    .into_pipeline_data())
+}

src/client/cloud.rs

@@ -84,11 +84,15 @@ impl CapellaClient {
         mac.update(bearer_payload.as_bytes());
         let mac_result = mac.finalize();
 
-        let bearer = format!(
-            "Bearer {}:{}",
-            self.access_key.clone(),
-            general_purpose::STANDARD.encode(mac_result.into_bytes()),
-        );
+        let bearer = if path.contains("/v4/") {
+            format!("Bearer {}", &self.secret_key)
+        } else {
+            format!(
+                "Bearer {}:{}",
+                self.access_key.clone(),
+                general_purpose::STANDARD.encode(mac_result.into_bytes())
+            )
+        };
 
         res_builder = res_builder
             .timeout(timeout)
@@ -304,6 +308,7 @@ pub enum CapellaRequest {
     // GetProject {
     //     project_id: String,
     // },
+    GetOrganizations,
     GetProjects,
     GetUsers {
         cluster_id: String,
@@ -389,6 +394,7 @@ impl CapellaRequest {
             // Self::GetProject { project_id } => {
             //     format!("/v2/projects/{}", project_id)
             // }
+            Self::GetOrganizations => "/v4/organizations".into(),
             Self::GetProjects => "/v2/projects".into(),
             Self::GetUsers { cluster_id } => {
                 format!("/v2/clusters/{}/users", cluster_id)
@@ -436,6 +442,7 @@ impl CapellaRequest {
             // Self::GetClusterStatus { .. } => HttpVerb::Get,
             // Self::GetOrgUsers => HttpVerb::Get,
             // Self::GetProject { .. } => HttpVerb::Get,
+            Self::GetOrganizations => HttpVerb::Get,
             Self::GetProjects => HttpVerb::Get,
             Self::GetUsers { .. } => HttpVerb::Get,
             // Self::UpdateAllowList { .. } => HttpVerb::Put,

src/main.rs

@@ -698,6 +698,7 @@ fn merge_couchbase_delta(context: &mut EngineState, state: Arc<Mutex<State>>) {
         working_set.add_decl(Box::new(Help));
         working_set.add_decl(Box::new(FakeData::new(state.clone())));
         working_set.add_decl(Box::new(Nodes::new(state.clone())));
+        working_set.add_decl(Box::new(Organizations::new(state.clone())));
         working_set.add_decl(Box::new(Ping::new(state.clone())));
         working_set.add_decl(Box::new(Projects::new(state.clone())));
         working_set.add_decl(Box::new(ProjectsCreate::new(state.clone())));