make aws credentials editable and refactor to hold name and id

This commit is contained in:
jfmonty2 committed 2026-11-20 06:14:34 -05:00
1 parent dbcf72fa38
commit 21efa29fdd
9 files changed
+289 -184

No files matched your search

Generated
+4 -2
View File
@@ -1447,6 +1447,7 @@ dependencies = [
"tempfile",
"testresult",
"thiserror 2.0.21",
"uuid",
]
[[package]]
@@ -1701,6 +1702,7 @@ dependencies = [
"libduckdb-sys",
"num-integer",
"strum 0.27.2",
"uuid",
]
[[package]]
@@ -7967,9 +7969,9 @@ checksum = "3a3b425286980a367278453f3b6d28cdcb134b574e5a35824a6ff5eebad50bb6"
[[package]]
name = "uuid"
version = "1.29.0"
version = "1.29.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4a0e2d11620c50695fe12bbbfde96b3477fe606e7284c22d505c12ce51214514"
checksum = "3c14b15dffa2f4bd712103e857140aa04a4f2ff6e955c77d7eb8e53ee02a3b64"
dependencies = [
"getrandom 0.4.3",
"js-sys",
+2 -1
View File
@@ -12,7 +12,7 @@ edition = "2024"
argon2 = { version = "0.6.0", features = ["parallel", "zeroize"] }
base64ct = "1.8.3"
dirs = "7.0.0"
duckdb = { version = "1.20000.1", features = ["bundled"] }
duckdb = { version = "1.20000.1", features = ["bundled", "uuid"] }
getrandom = { version = "0.4.3", features = ["sys_rng"] }
gpui-kit = "0.7.0"
gpui-omarchy = "0.2.1"
@@ -22,6 +22,7 @@ serde = "1.0.229"
serde_json = "1.0.154"
testresult = "0.4.2"
thiserror = "2.0.21"
uuid = { version = "1.29.3", features = ["v4", "serde"] }
[dev-dependencies]
gpui-kit = { version = "0.7.0", features = ["test-support"] }
+2 -1
View File
@@ -5,7 +5,8 @@ INSERT INTO config VALUES ('{}');
CREATE TABLE aws_credentials (
name VARCHAR PRIMARY KEY NOT NULL,
id UUID PRIMARY KEY NOT NULL,
name VARCHAR UNIQUE NOT NULL,
created_at TIMESTAMP WITH TIME ZONE NOT NULL,
updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
access_key_id VARCHAR UNIQUE NOT NULL,
+1 -1
View File
@@ -5,7 +5,7 @@ use gpui_kit::{AssetSource, Result, SharedString};
// gpui-kit only embeds the icons its own components use, so anything else has to be listed here
icon_assets!(CreddyIcons, [Key, LogOut, ShieldCheck]);
icon_assets!(CreddyIcons, [Key, LogOut, Pencil, ShieldCheck]);
/// Our extra icons, falling back to gpui-kit's defaults.
pub struct CreddyAssets;
+8
View File
@@ -30,6 +30,7 @@ pub struct PassphraseInputBuilder {
id: SharedString,
show: Option<Entity<bool>>,
placeholder: SharedString,
value: SharedString,
}
impl PassphraseInputBuilder {
@@ -44,6 +45,11 @@ impl PassphraseInputBuilder {
self
}
pub fn value(mut self, value: impl Into<SharedString>) -> Self {
self.value = value.into();
self
}
pub fn build(self, window: &mut Window, cx: &mut App) -> Entity<PassphraseInput> {
let show = self.show.unwrap_or_else(|| cx.new(|_| false));
cx.new(|cx| {
@@ -52,6 +58,7 @@ impl PassphraseInputBuilder {
InputState::new(window, cx)
.masked(masked)
.placeholder(self.placeholder)
.default_value(self.value)
});
// keep this field's masking in sync with the shared flag
@@ -88,6 +95,7 @@ impl PassphraseInput {
id: id.into(),
show: None,
placeholder: SharedString::default(),
value: SharedString::default(),
}
}
+5 -2
View File
@@ -1,14 +1,17 @@
use jiff::Timestamp;
use serde::{Serialize, Deserialize};
use uuid::Uuid;
#[derive(Clone, Debug, Serialize, Deserialize)]
#[derive(Clone, Debug, Eq, PartialEq, Default, Serialize, Deserialize)]
pub struct AwsCredential {
pub id: Uuid,
pub name: String,
pub access_key_id: String,
pub secret_access_key: String,
pub is_default: bool,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub struct AwsSessionCredential {
pub version: usize,
pub access_key_id: String,
+92 -83
View File
@@ -1,4 +1,3 @@
use std::collections::HashMap;
use duckdb::{Error, params};
use crate::credentials::AwsCredential;
use super::Db;
@@ -7,27 +6,37 @@ impl Db {
pub fn load_aws_credential(&self, name: &str) -> Result<AwsCredential, Error> {
let conn = self.connection.lock().unwrap();
conn.query_row(
"SELECT access_key_id, secret_access_key, is_default FROM aws_credentials WHERE name = ?",
"SELECT
id,
name,
access_key_id,
secret_access_key,
is_default
FROM aws_credentials
WHERE name = ?",
params![name],
|row| Ok(AwsCredential {
access_key_id: row.get(0)?,
secret_access_key: row.get(1)?,
is_default: row.get(2)?,
id: row.get(0)?,
name: row.get(1)?,
access_key_id: row.get(2)?,
secret_access_key: row.get(3)?,
is_default: row.get(4)?,
})
)
}
pub fn save_aws_credential(&self, name: &str, cred: &AwsCredential) -> Result<(), Error> {
pub fn save_aws_credential(&self, cred: &AwsCredential) -> Result<(), Error> {
let mut conn = self.connection.lock().unwrap();
let tx = conn.transaction()?;
if cred.is_default {
tx.execute(
"UPDATE aws_credentials SET is_default = false WHERE is_default AND name != ?",
params![name],
"UPDATE aws_credentials SET is_default = false WHERE is_default AND id != ?",
params![cred.id],
)?;
}
tx.execute(
"INSERT INTO aws_credentials (
id,
name,
created_at,
updated_at,
@@ -35,52 +44,66 @@ impl Db {
secret_access_key,
is_default,
)
VALUES (?, now(), now(), ?, ?, ?)
ON CONFLICT (name) DO UPDATE
VALUES (?, ?, now(), now(), ?, ?, ?)
ON CONFLICT (id) DO UPDATE
SET
name = EXCLUDED.name,
updated_at = now(),
access_key_id = EXCLUDED.access_key_id,
secret_access_key = EXCLUDED.secret_access_key,
is_default = EXCLUDED.is_default",
params![name, cred.access_key_id, cred.secret_access_key, cred.is_default],
params![cred.id, cred.name, cred.access_key_id, cred.secret_access_key, cred.is_default],
)?;
tx.commit()
}
pub fn list_aws_credentials(&self) -> Result<HashMap<String, AwsCredential>, Error> {
pub fn list_aws_credentials(&self) -> Result<Vec<AwsCredential>, Error> {
let conn = self.connection.lock().unwrap();
let mut stmt = conn.prepare("SELECT name, access_key_id, secret_access_key, is_default FROM aws_credentials")?;
let rows = stmt.query_map([], |row| {
let key: String = row.get(0)?;
let cred = AwsCredential{
access_key_id: row.get(1)?,
secret_access_key: row.get(2)?,
is_default: row.get(3)?,
};
Ok((key, cred))
})?;
rows.collect()
let mut stmt = conn.prepare(
"SELECT
id,
name,
access_key_id,
secret_access_key,
is_default
FROM aws_credentials
ORDER BY created_at"
)?;
stmt.query_map([], |row| {
Ok(AwsCredential{
id: row.get(0)?,
name: row.get(1)?,
access_key_id: row.get(2)?,
secret_access_key: row.get(3)?,
is_default: row.get(4)?,
})
})?.collect()
}
}
#[cfg(test)]
mod tests {
use testresult::TestResult;
use uuid::Uuid;
use crate::test_data::TestEnv;
use super::*;
fn test_cred(name: &str, access_key_id: &str) -> AwsCredential {
AwsCredential {
id: Uuid::new_v4(),
name: name.into(),
access_key_id: access_key_id.into(),
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
}
}
#[test]
fn test_save() -> TestResult {
let env = TestEnv::new()?;
let db = env.db()?;
let cred = AwsCredential {
access_key_id: "AKIAEXAMPLE".into(),
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
};
db.save_aws_credential("test", &cred)?;
db.save_aws_credential(&test_cred("test", "AKIAEXAMPLE"))?;
Ok(())
}
@@ -89,17 +112,12 @@ mod tests {
let env = TestEnv::new()?;
let db = env.db()?;
let cred = AwsCredential {
access_key_id: "AKIAEXAMPLE".into(),
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
};
db.save_aws_credential("test", &cred)?;
let cred = test_cred("test", "AKIAEXAMPLE");
db.save_aws_credential(&cred)?;
let loaded = db.load_aws_credential("test")?;
assert_eq!(loaded.access_key_id, cred.access_key_id);
assert_eq!(loaded.secret_access_key, cred.secret_access_key);
assert_eq!(loaded, cred);
Ok(())
}
@@ -108,23 +126,23 @@ mod tests {
let env = TestEnv::new()?;
let db = env.db()?;
let mut cred = AwsCredential {
access_key_id: "KEY1".into(),
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
};
db.save_aws_credential("test", &cred)?;
let mut cred = test_cred("test", "KEY1");
db.save_aws_credential(&cred)?;
cred.name = "renamed".into();
cred.access_key_id = "KEY2".into();
db.save_aws_credential("test", &cred)?;
db.save_aws_credential(&cred)?;
let loaded = db.load_aws_credential("test")?;
assert_eq!(loaded.access_key_id, "KEY2");
let creds = db.list_aws_credentials()?;
assert_eq!(creds.len(), 1);
assert_eq!(creds[0].id, cred.id);
assert_eq!(creds[0].name, "renamed");
assert_eq!(creds[0].access_key_id, "KEY2");
// confirm that updated_at was modified, but not created_at
let conn = db.connection.lock().unwrap();
let (created_at, updated_at): (i64, i64) = conn.query_row(
"SELECT created_at, updated_at FROM aws_credentials WHERE name = 'test'",
"SELECT created_at, updated_at FROM aws_credentials WHERE name = 'renamed'",
[],
|row| Ok((row.get(0)?, row.get(1)?))
)?;
@@ -133,34 +151,31 @@ mod tests {
Ok(())
}
#[test]
fn test_duplicate_name() -> TestResult {
let env = TestEnv::new()?;
let db = env.db()?;
db.save_aws_credential(&test_cred("test", "KEY1"))?;
assert!(db.save_aws_credential(&test_cred("test", "KEY2")).is_err());
Ok(())
}
#[test]
fn test_list() -> TestResult {
let env = TestEnv::new()?;
let db = env.db()?;
let cred1 = AwsCredential {
access_key_id: "KEY1".into(),
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
};
db.save_aws_credential("test", &cred1)?;
let cred2 = AwsCredential {
access_key_id: "KEY2".into(),
secret_access_key: "EXAMPLESECRET2".into(),
is_default: false,
};
db.save_aws_credential("test2", &cred2)?;
// names are out of alphabetical order, since the list should be in order of creation
let cred1 = test_cred("test2", "KEY1");
db.save_aws_credential(&cred1)?;
let cred2 = test_cred("test1", "KEY2");
db.save_aws_credential(&cred2)?;
let creds = db.list_aws_credentials()?;
let loaded1 = creds.get("test").unwrap();
assert_eq!(loaded1.access_key_id, cred1.access_key_id);
assert_eq!(loaded1.secret_access_key, cred1.secret_access_key);
let loaded2 = creds.get("test2").unwrap();
assert_eq!(loaded2.access_key_id, cred2.access_key_id);
assert_eq!(loaded2.secret_access_key, cred2.secret_access_key);
assert_eq!(creds.len(), 2);
assert_eq!(creds[0], cred1);
assert_eq!(creds[1], cred2);
Ok(())
}
@@ -170,28 +185,22 @@ mod tests {
let env = TestEnv::new()?;
let db = env.db()?;
let cred1 = AwsCredential {
access_key_id: "KEY1".into(),
secret_access_key: "EXAMPLESECRET".into(),
is_default: true,
};
db.save_aws_credential("test", &cred1)?;
let mut cred1 = test_cred("test", "KEY1");
cred1.is_default = true;
db.save_aws_credential(&cred1)?;
let cred2 = AwsCredential {
access_key_id: "KEY2".into(),
secret_access_key: "EXAMPLESECRET2".into(),
is_default: true,
};
db.save_aws_credential("test2", &cred2)?;
let mut cred2 = test_cred("test2", "KEY2");
cred2.is_default = true;
db.save_aws_credential(&cred2)?;
assert!(!db.load_aws_credential("test")?.is_default);
assert!(db.load_aws_credential("test2")?.is_default);
// re-saving the current default shouldn't trip over its own row
db.save_aws_credential("test2", &cred2)?;
db.save_aws_credential(&cred2)?;
assert!(db.load_aws_credential("test2")?.is_default);
db.save_aws_credential("test", &cred1)?;
db.save_aws_credential(&cred1)?;
assert!(db.load_aws_credential("test")?.is_default);
assert!(!db.load_aws_credential("test2")?.is_default);
+49 -2
View File
@@ -89,6 +89,7 @@ fn main() {
mod tests {
use gpui_kit::{AnyWindowHandle, TestAppContext};
use gpui_kit::test::TestWindowExt;
use uuid::Uuid;
use super::*;
use crate::credentials::AwsCredential;
use crate::test_data::{TEST_PASSPHRASE, TestEnv};
@@ -259,11 +260,13 @@ mod tests {
fn test_credentials_tabs(cx: &mut TestAppContext) {
let env = TestEnv::new().unwrap();
let cred = AwsCredential {
id: Uuid::new_v4(),
name: "work".into(),
access_key_id: "AKIAEXAMPLE".into(),
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
};
env.db().unwrap().save_aws_credential("work", &cred).unwrap();
env.db().unwrap().save_aws_credential(&cred).unwrap();
let window = open_app(&env, cx);
fill(window, "passphrase", TEST_PASSPHRASE, cx);
click(window, "submit", cx);
@@ -328,11 +331,13 @@ mod tests {
fn test_add_aws_credential_duplicate_name(cx: &mut TestAppContext) {
let env = TestEnv::new().unwrap();
let cred = AwsCredential {
id: Uuid::new_v4(),
name: "work".into(),
access_key_id: "AKIAEXAMPLE".into(),
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
};
env.db().unwrap().save_aws_credential("work", &cred).unwrap();
env.db().unwrap().save_aws_credential(&cred).unwrap();
let window = open_app(&env, cx);
fill(window, "passphrase", TEST_PASSPHRASE, cx);
click(window, "submit", cx);
@@ -354,4 +359,46 @@ mod tests {
});
assert_eq!(saved.access_key_id, "AKIAEXAMPLE");
}
#[gpui_kit::test]
fn test_edit_aws_credential(cx: &mut TestAppContext) {
let env = TestEnv::new().unwrap();
let cred = AwsCredential {
id: Uuid::new_v4(),
name: "work".into(),
access_key_id: "AKIAEXAMPLE".into(),
secret_access_key: "EXAMPLESECRET".into(),
is_default: false,
};
env.db().unwrap().save_aws_credential(&cred).unwrap();
let window = open_app(&env, cx);
fill(window, "passphrase", TEST_PASSPHRASE, cx);
click(window, "submit", cx);
click(window, "credentials", cx);
click(window, "edit-work", cx);
act(window, cx, |window, cx| {
window.click("aws-name", cx);
window.press("ctrl-a", cx);
window.input("personal", cx);
});
click(window, "aws-default", cx);
click(window, "aws-save", cx);
assert_eq!(error_message(window, cx), None);
assert!(is_visible(window, "personal", cx));
assert!(!is_visible(window, "work", cx));
let creds = cx.read(|cx| {
let AppSession::Unlocked(db) = cx.global::<AppSession>() else { panic!("locked") };
db.list_aws_credentials().unwrap()
});
assert_eq!(creds.len(), 1);
// fields that weren't touched keep the values the form was opened with
assert_eq!(creds[0].id, cred.id);
assert_eq!(creds[0].name, "personal");
assert_eq!(creds[0].access_key_id, "AKIAEXAMPLE");
assert_eq!(creds[0].secret_access_key, "EXAMPLESECRET");
assert!(creds[0].is_default);
}
}
+126 -92
View File
@@ -12,16 +12,19 @@ use crate::components::{PassphraseInput, PassphraseInputEvent, colored_switch, e
use crate::credentials::AwsCredential;
use crate::session::AppSession;
use super::Screen;
use uuid::Uuid;
pub struct CredentialsScreen {
tab: usize,
aws: Vec<(String, AwsCredential)>,
aws: Vec<AwsCredential>,
aws_form: Option<AwsForm>,
error: Option<SharedString>,
}
struct AwsForm {
/// The id of the credential being edited, or None if this is a new one.
editing: Option<Uuid>,
name: Entity<InputState>,
access_key_id: Entity<InputState>,
secret_access_key: Entity<PassphraseInput>,
@@ -43,18 +46,25 @@ impl CredentialsScreen {
match db.list_aws_credentials() {
Ok(creds) => {
self.aws = creds.into_iter().collect();
self.aws.sort_by(|a, b| a.0.cmp(&b.0));
self.aws = creds;
self.error = None;
},
Err(e) => self.error = Some(format!("Failed to load credentials: {e}").into()),
}
}
fn add_aws(&mut self, window: &mut Window, cx: &mut Context<Self>) {
let name = cx.new(|cx| InputState::new(window, cx));
let access_key_id = cx.new(|cx| InputState::new(window, cx));
let secret_access_key = PassphraseInput::builder("aws-secret").build(window, cx);
fn open_aws_form(&mut self, editing: Option<Uuid>, window: &mut Window, cx: &mut Context<Self>) {
let existing = self.aws
.iter()
.find(|cred| Some(cred.id) == editing)
.cloned()
.unwrap_or_default();
let name = cx.new(|cx| InputState::new(window, cx).default_value(existing.name));
let access_key_id = cx.new(|cx| InputState::new(window, cx).default_value(existing.access_key_id));
let secret_access_key = PassphraseInput::builder("aws-secret")
.value(existing.secret_access_key)
.build(window, cx);
name.update(cx, |name, cx| name.focus(window, cx));
let mut _subscriptions = Vec::new();
@@ -72,10 +82,11 @@ impl CredentialsScreen {
}));
self.aws_form = Some(AwsForm {
editing,
name,
access_key_id,
secret_access_key,
is_default: false,
is_default: existing.is_default,
_subscriptions,
});
self.error = None;
@@ -84,21 +95,22 @@ impl CredentialsScreen {
fn save_aws(&mut self, cx: &mut Context<Self>) {
let Some(form) = &self.aws_form else { return };
let name = form.name.read(cx).value().trim().to_string();
let editing = form.editing;
let cred = AwsCredential {
id: editing.unwrap_or_else(Uuid::new_v4),
name: form.name.read(cx).value().trim().to_string(),
access_key_id: form.access_key_id.read(cx).value().trim().to_string(),
secret_access_key: form.secret_access_key.read(cx).value(cx).trim().to_string(),
is_default: form.is_default,
};
if name.is_empty() || cred.access_key_id.is_empty() || cred.secret_access_key.is_empty() {
if cred.name.is_empty() || cred.access_key_id.is_empty() || cred.secret_access_key.is_empty() {
self.error = Some("All fields are required.".into());
cx.notify();
return;
}
// saving is an upsert, so without this a new credential would silently replace the old one
if self.aws.iter().any(|(existing, _)| *existing == name) {
self.error = Some(format!("An AWS credential named \"{name}\" already exists.").into());
if self.aws.iter().any(|existing| existing.name == cred.name && existing.id != cred.id) {
self.error = Some(format!("An AWS credential named \"{}\" already exists.", cred.name).into());
cx.notify();
return;
}
@@ -106,7 +118,7 @@ impl CredentialsScreen {
let AppSession::Unlocked(db) = cx.global::<AppSession>() else {
unreachable!("credentials screen is only shown while unlocked");
};
match db.save_aws_credential(&name, &cred) {
match db.save_aws_credential(&cred) {
Ok(()) => {
self.aws_form = None;
self.load_aws(cx);
@@ -119,43 +131,67 @@ impl CredentialsScreen {
fn render_aws_tab(&self, window: &mut Window, cx: &mut Context<Self>) -> Div {
let t = cx.omarchy().clone();
let list = if self.aws.is_empty() {
empty_state("AWS access keys", "You have no saved AWS credentials.", cx)
} else {
div()
.flex()
.flex_col()
.gap(rems(0.5))
.children(self.aws.iter().map(|(name, cred)| {
div()
.id(SharedString::from(name))
.test_support()
.flex()
.items_center()
.gap(rems(0.75))
.p(rems(0.625))
.border_1()
.border_color(if cred.is_default { t.accent } else { t.border })
.child(div().font_weight(FontWeight::BOLD).child(name.clone()))
.children(cred.is_default.then(|| badge("Default", Status::Success, cx)))
.child(
div()
.ml_auto()
.font_family(t.mono_font.clone())
.text_color(t.secondary)
.child(cred.access_key_id.clone()),
)
}))
};
let mut panel = div().flex().flex_col().gap(rems(0.5));
if self.aws.is_empty() {
panel = panel.child(empty_state("AWS access keys", "You have no saved AWS credentials.", cx));
}
for cred in &self.aws {
if let Some(form) = &self.aws_form
&& form.editing == Some(cred.id)
{
panel = panel.child(self.render_aws_form(form, window, cx));
continue;
}
let Some(form) = &self.aws_form else {
return div().flex().flex_col().gap(rems(1.)).child(list).child(
let id = cred.id;
panel = panel.child(
div()
.id(SharedString::from(&cred.name))
.test_support()
.flex()
.items_center()
.gap(rems(0.75))
.p(rems(0.625))
.border_1()
.border_color(if cred.is_default { t.accent } else { t.border })
.child(div().font_weight(FontWeight::BOLD).child(cred.name.clone()))
.children(cred.is_default.then(|| badge("Default", Status::Success, cx)))
.child(
div()
.ml_auto()
.font_family(t.mono_font.clone())
.text_color(t.secondary)
.child(cred.access_key_id.clone()),
)
.child(
icon_button(
SharedString::from(format!("edit-{}", cred.name)),
IconName::Pencil,
"Edit",
ButtonVariant::Outline,
cx,
)
.on_click(cx.listener(move |this, _, window, cx| {
this.open_aws_form(Some(id), window, cx)
})),
),
);
}
match &self.aws_form {
None => panel.child(
button("aws-add", "Add", ButtonVariant::Primary, cx)
.self_center()
.on_click(cx.listener(|this, _, window, cx| this.add_aws(window, cx))),
);
};
.mt(rems(0.5))
.on_click(cx.listener(|this, _, window, cx| this.open_aws_form(None, window, cx))),
),
Some(form) if form.editing.is_none() => panel.child(self.render_aws_form(form, window, cx)),
Some(_) => panel,
}
}
fn render_aws_form(&self, form: &AwsForm, window: &mut Window, cx: &mut Context<Self>) -> Div {
let t = cx.omarchy().clone();
let field = |label: &'static str, input: gpui_kit::AnyElement| {
div()
.flex()
@@ -166,51 +202,49 @@ impl CredentialsScreen {
};
let this = cx.entity();
div().flex().flex_col().gap(rems(1.)).child(list).child(
div()
.flex()
.flex_col()
.gap(rems(1.))
.p(rems(1.))
.border_1()
.border_color(t.border)
.child(field("Name", input("aws-name", &form.name, window, cx).into_any_element()))
.child(field(
"Key ID",
input("aws-key-id", &form.access_key_id, window, cx)
.font_family(t.mono_font.clone())
.into_any_element(),
))
.child(field("Secret key", form.secret_access_key.clone().into_any_element()))
.child(
div()
.flex()
.items_center()
.gap(rems(0.5))
.child(
colored_switch("aws-default", "Default AWS access key", form.is_default, t.success, cx)
.on_change(move |value, _, _, cx| this.update(cx, |this, cx| {
if let Some(form) = &mut this.aws_form {
form.is_default = value;
}
cx.notify();
})),
)
.child(
button("aws-cancel", "Cancel", ButtonVariant::Outline, cx)
.ml_auto()
.on_click(cx.listener(|this, _, _, cx| {
this.aws_form = None;
this.error = None;
cx.notify();
})),
)
.child(
button("aws-save", "Save", ButtonVariant::Primary, cx)
.on_click(cx.listener(|this, _, _, cx| this.save_aws(cx))),
),
),
)
div()
.flex()
.flex_col()
.gap(rems(1.))
.p(rems(1.))
.border_1()
.border_color(t.border)
.child(field("Name", input("aws-name", &form.name, window, cx).into_any_element()))
.child(field(
"Key ID",
input("aws-key-id", &form.access_key_id, window, cx)
.font_family(t.mono_font.clone())
.into_any_element(),
))
.child(field("Secret key", form.secret_access_key.clone().into_any_element()))
.child(
div()
.flex()
.items_center()
.gap(rems(0.5))
.child(
colored_switch("aws-default", "Default AWS access key", form.is_default, t.success, cx)
.on_change(move |value, _, _, cx| this.update(cx, |this, cx| {
if let Some(form) = &mut this.aws_form {
form.is_default = value;
}
cx.notify();
})),
)
.child(
button("aws-cancel", "Cancel", ButtonVariant::Outline, cx)
.ml_auto()
.on_click(cx.listener(|this, _, _, cx| {
this.aws_form = None;
this.error = None;
cx.notify();
})),
)
.child(
button("aws-save", "Save", ButtonVariant::Primary, cx)
.on_click(cx.listener(|this, _, _, cx| this.save_aws(cx))),
),
)
}
}