# Rust SDK

<figure><img src="https://859776093-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FPL6k1aGsLiFiiJ3Y7zCl%2Fuploads%2F5vcM5JWGy4uvirJdJ09U%2Fimage.png?alt=media&#x26;token=e630112d-d8a2-4f1d-8ef7-c58ac81999e0" alt=""><figcaption></figcaption></figure>

## ダウンロードとインストール

### Cargoでパッケージ追加

```
cargo add keeper-secrets-manager-core
```

### ソースコード

Rustのソースコードについては[GitHubリポジトリ](https://github.com/Keeper-Security/secrets-manager/tree/master/sdk/rust)をご覧ください。

## SDKの使用方法

### 初期化

{% hint style="info" %}
トークンのみで新しい設定を生成して後で使用する場合は、トークンをバインドして `config.json` を完全に生成するために、少なくとも1回の読み取り操作が必要です
{% endhint %}

{% tabs %}
{% tab title="シークレットマネージャー" %}

```
SecretsManager::new(client_options)?
```

{% endtab %}

{% tab title="使用例" %}

```rust
use keeper_secrets_manager_core::{ClientOptions, SecretsManager,storage::FileKeyValueStorage}

fn main()-> Result<(), KSMRError>{
    let client_options = ClientOptions::new_client_options_with_token(token, config);
    let mut secrets_manager = SecretsManager::new(client_options)?;
    Ok(())
}
```

{% endtab %}
{% endtabs %}

<table data-header-hidden><thead><tr><th width="150">パラメータ</th><th width="150">必須</th><th>説明</th><th>型</th></tr></thead><tbody><tr><td>パラメータ</td><td>必須</td><td>説明</td><td>型</td></tr><tr><td>token</td><td>はい</td><td>ワンタイムアクセストークン</td><td>String</td></tr><tr><td>config</td><td>はい</td><td>ストレージ設定</td><td><code>KeyValueStorage</code></td></tr></tbody></table>

### シークレットの取得

{% tabs %}
{% tab title="Get Secrets" %}

```
let records_filter = Vec::new(); // UIDに基づいて必要に応じてフィルターを追加
let secrets = secrets_manager.get_secrets(records_filter)?;
```

{% endtab %}

{% tab title="例: すべてのシークレットを取得" %}
use keeper\_secrets\_manager\_core::{core::{ClientOptions, SecretsManager}, custom\_error::KSMRError, storage::FileKeyValueStorage};

fn main()-> Result<(), KSMRError>{ let token = "".to\_string(); let file\_name = FileKeyValueStorage::new\_config\_storage("test.json".to\_string())?; let client\_options = ClientOptions::new\_client\_options(token, file\_name);

```
let mut secrets_manager = SecretsManager::new(client_options)?;
let secrets = secrets_manager.get_secrets(Vec::new())?;

for secret in secrets {
    secret.print();
    println!("---");
}
Ok(())
```

}
{% endtab %}

{% tab title="例: フィルター付きで取得" %}
use keeper\_secrets\_manager\_core::{core::{ClientOptions, SecretsManager}, custom\_error::KSMRError, storage::FileKeyValueStorage};

fn main()-> Result<(), KSMRError>{ let token = "".to\_string(); let file\_name = FileKeyValueStorage::new\_config\_storage("test.json".to\_string())?; let client\_options = ClientOptions::new\_client\_options(token, file\_name);

```
let mut secrets_manager = SecretsManager::new(client_options)?;
let records_filter = vec!["record_uid1","record_uid2"]; // UIDに基づいて必要に応じてフィルターを追加
let secrets = secrets_manager.get_secrets(records_filter)?;

for secret in secrets {
    secret.print();
    println!("---");
}
Ok(())
```

}
{% endtab %}
{% endtabs %}

<table data-header-hidden><thead><tr><th width="150">パラメータ</th><th width="150">型</th><th width="150">必須</th><th width="150">デフォルト</th><th>説明</th></tr></thead><tbody><tr><td>パラメータ</td><td>型</td><td>必須</td><td>デフォルト</td><td>説明</td></tr><tr><td><code>uids</code></td><td><code>Vec&#x3C;String></code></td><td>任意</td><td>なし</td><td>取得するレコードUID</td></tr></tbody></table>

#### レスポンス

型: Vec

すべてのKeeperレコード、または指定したUIDのレコード

デフォルトでは、指定したトークンでアクセス可能なすべてのレコードを取得します

### シークレットから値を取得

#### パスワードを取得

Keeperシークレットマネージャーからシークレットを取得した後に、そのパスワードを参照できます。

{% tabs %}
{% tab title="パスワードを取得" %}

```rust
secret.get_standard_field_value('password', true);
```

{% endtab %}

{% tab title="例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーのセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;
    
    // レコードUIDを指定してシークレットを取得
    let secrets = secrets_manager.get_secrets(vec!["record_uid".to_string()])?;
    let secret = match secrets.len(){
        0 => return Err(KSMRError::CustomError("no secret with given uid is found".to_string())),
        _ => &secrets[0],
    };
    // レコードからパスワードを取得
    let my_secret_password = secret.get_standard_field_value("password", true);
    Ok(())
}
```

{% endtab %}
{% endtabs %}

#### 標準フィールドの取得

{% tabs %}
{% tab title="標準フィールド" %}

```rust
secret.get_standard_field_value(“FIELD_TYPE”.to_string(), true);
```

{% endtab %}

{% tab title="標準フィールドの例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::FileKeyValueStorage,
    custom_error::KSMRError,
    enums::StandardFieldTypeEnum
};

fn main()-> Result<(), KSMRError>{
    // Secrets Managerのセットアップ
    let token = "your_token_goes_here".to_string();
    let config = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
    let client_options = ClientOptions::new_client_options_with_token(token, config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // レコードUIDを指定してシークレットを取得
    let secrets = secrets_manager.get_secrets(vec!["record_uid".to_string()])?;
    let secret = match secrets.len(){
        0 => return Err(KSMRError::CustomError("no secret with given uid is found".to_string())),
        _ => &secrets[0],
    };
    // タイプミスを避けるためStandardFieldTypeEnumを使用
    let login_field = StandardFieldTypeEnum::LOGIN.get_type().to_string();
    // シークレットからログインフィールドを取得
    let my_secret_login = secret.get_standard_field_value(login_field, true)
    Ok(())
}
```

{% endtab %}
{% endtabs %}

| パラメータ        | 型         | 必須 | デフォルト | 説明           |
| ------------ | --------- | -- | ----- | ------------ |
| `field_type` | `String`  | はい | None  | 取得するフィールドタイプ |
| `single`     | `boolean` | 任意 | False | 最初の値のみを返す    |

フィールドタイプはKeeper[レコードタイプ](https://docs.keeper.io/enterprise-guide/record-types)に基づきます。利用可能なフィールドの詳細な一覧については、コマンダーで [`record-type-info`](https://docs.keeper.io/jp/keeperpam/commander-cli/command-reference/record-commands/record-type-commands#record-type-info-command) コマンドをご参照ください。

#### カスタムフィールドの取得

{% tabs %}
{% tab title="カスタムフィールド" %}

```rust
secret.get_custom_field_value(“FIELD_TYPE”, true);
```

{% endtab %}

{% tab title="カスタムフィールドの例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // レコードUIDで特定のシークレットを取得する
    let secrets = secrets_manager.get_secrets(vec!["record_uid".to_string()])?;
    let secret = match secrets.len(){
        0 => return Err(KSMRError::CustomError("no secret with given uid is found".to_string())),
        _ => &secrets[0],
    };
    // カスタムフィールドを取得する、例: APIキー
    let api_key = secret.get_custom_field_value(“API Key”, true)
    Ok(())
}
```

{% endtab %}
{% endtabs %}

| パラメータ        | 型         | 必須 | デフォルト | 説明          |
| ------------ | --------- | -- | ----- | ----------- |
| `field_type` | `String`  | はい | -     | 取得するフィールドの型 |
| `single`     | `boolean` | 任意 | False | 最初の値のみを返す   |

カスタムフィールドはレコードタイプ定義に含まれないフィールドで、ユーザーによって追加できます。

#### レスポンス

型: `String` または `Vec<String>`

フィールドの値または値の集合。単一値になるのは `single=true` オプションが渡された場合のみです。

#### タイトルによるレコード検索

{% tabs %}
{% tab title="タイトルによるレコード検索" %}

```rust
secrets_manager.get_secret_by_title(record_title);
```

{% endtab %}

{% tab title="タイトルによるレコード検索の例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // secrets managerをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // レコードタイトルに一致するすべてのシークレットを取得する
    let secrets = secrets_manager.get_secret_by_title("My Credentials").unwrap().unwrap();
    Ok(())
}
```

{% endtab %}
{% endtabs %}

#### レスポンス

型: `Record<Option<Vec<Record>>>`

<table><thead><tr><th>パラメータ</th><th width="121.92578125">型</th><th width="130.12890625">必須</th><th>説明</th></tr></thead><tbody><tr><td><code>record_title</code></td><td><code>&#x26;str</code></td><td>はい</td><td>取得するレコードのタイトル</td></tr></tbody></table>

#### Keeper表記法を使用して値を取得

{% tabs %}
{% tab title="表記を取得" %}

```rust
secrets_manager.get_notation(query)
```

{% endtab %}

{% tab title="表記の例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // 表記法に一致するすべてのシークレットを取得する
    let mut notation = "HDQTnxkTcPSOsHNAlbI4aQ/field/login".to_string();
    let mut result = secrets_manager.get_notation(notation)?;
    Ok(())
}
```

{% endtab %}
{% endtabs %}

Keeper表記法の形式と機能については、[こちらのページ](https://docs.keeper.io/jp/keeperpam/secrets-manager/about/keeper-notation) をご参照ください。

| パラメーター  | 型        | 必須 | デフォルト | 説明                               |
| ------- | -------- | -- | ----- | -------------------------------- |
| `query` | `String` | はい | -     | 指定したフィールドから値を取得するためのKeeper表記法クエリ |

#### 戻り値

クエリで指定したフィールドの値

型: `String` または `Vec<String>`

#### TOTPコードの取得

{% tabs %}
{% tab title="TOTPコードの取得" %}

```
get_totp_code(&url)
```

{% endtab %}

{% tab title="使用例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // レコードからTOTPのURL値を取得する
    let value = record.get_standard_field_value(StandardFieldTypeEnum::ONETIMECODE.get_type(), false)
    let url: String = utils::get_otp_url_from_value_obj(value)?;

    // TOTPのURLからコードを取得する
    let totp = utils::get_totp_code(&url)?;
    println!("{}", totp.get_code());
    Ok(())
}
```

{% endtab %}
{% endtabs %}

#### 戻り値

型: `Result<TotpCode,KSMRError>`

| パラメータ | 型        | 必須 | 説明       |
| ----- | -------- | -- | -------- |
| `url` | `String` | はい | TOTP URL |

### シークレットの更新

{% hint style="warning" %}
レコード更新コマンドは、成功してもローカルのレコードデータ (特に更新後のレコードリビジョン) が更新されないため、すでに更新されたレコードに連続して更新を行うと、リビジョンの不一致により失敗します。各更新バッチの後には、必ず更新されたすべてのレコードを再読み込みしてください。
{% endhint %}

#### シークレットへの変更を保存する

{% tabs %}
{% tab title="シークレットを保存" %}

```rust
secrets_manager.save(Record, UpdateTransactionType)
```

{% endtab %}

{% tab title="シークレットの更新の保存" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // UIDで特定のシークレットを取得する
    let secret_to_update = secrets_manager.get_secrets(["<RECORD UID>".to_string()])?;

    // フィールド値を更新する
    let field_type= StandardFieldTypeEnum::LOGIN.get_type();
    secret_to_update.set_standard_field_value_mut(field_type, "sample@ks.com".into())?;

    let transaction_type: Option<UpdateTransactionType> = Some(UpdateTransactionType::None);

    secrets_manager.save(secret_to_update, transaction_type);
    Ok(())
}
```

{% endtab %}
{% endtabs %}

| パラメータ              | 型                       | 必須 | デフォルト | 説明               |
| ------------------ | ----------------------- | -- | ----- | ---------------- |
| `record`           | `Record`                | はい | ​     | ストレージおよびクエリ構成    |
| `transaction_type` | `UpdateTransactionType` | はい | ​     | トランザクション更新のための構成 |

フィールド値は `set_standard_field_value_mut` または `set_custom_field_value_mut` を使用して設定します

フィールドはタイプで検索します。

フィールドタイプの一覧については、[レコードタイプ](https://docs.keeper.io/enterprise-guide/record-types)のページをご参照ください。一部のフィールドは複数の値を持つ場合があり、その場合は値をリストに設定できます。

#### 標準フィールド値の更新

{% tabs %}
{% tab title="標準フィールド値の更新" %}

```rust
secret.set_standard_field_value_mut(field_type, "new_field_value".into())
```

{% endtab %}

{% tab title="標準フィールド更新の例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // UIDで特定のシークレットを取得する
    let secret_to_update = secrets_manager.get_secrets(["<RECORD UID>".to_string()])?;

    // フィールド値を更新する
    let field_type= StandardFieldTypeEnum::LOGIN.get_type();
    secret_to_update.set_standard_field_value_mut(field_type, "sample@ks.com".into())?;

    let transaction_type: Option<UpdateTransactionType> = Some(UpdateTransactionType::None);

    secrets_manager.save(secret_to_update, transaction_type);
    Ok(())
}
```

{% endtab %}
{% endtabs %}

| パラメータ              | 型                       | 必須 | デフォルト | 説明               |
| ------------------ | ----------------------- | -- | ----- | ---------------- |
| `field_type`       | `String`                | はい | ​     | 取得するフィールドの型      |
| `transaction_type` | `UpdateTransactionType` | はい | なし    | トランザクション更新のための構成 |

フィールドはタイプで検索します。フィールドタイプの一覧については、[レコードタイプ](https://docs.keeper.io/enterprise-guide/record-types)のページをご参照ください。

#### カスタムフィールド値の更新

{% tabs %}
{% tab title="カスタムフィールドの更新" %}

```rust
secret.set_custom_field_value_mut(field_type, "new_field_value".into());
```

{% endtab %}

{% tab title="カスタムフィールド更新の例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // UIDで特定のシークレットを取得する
    let secret_to_update = secrets_manager.get_secrets(["<RECORD UID>".to_string()])?;

    // フィールド値を更新する
    secret_to_update.set_custom_field_value_mut("Email", "sample@ks.com".into())?;

    let transaction_type: Option<UpdateTransactionType> = Some(UpdateTransactionType::None);

    secrets_manager.save(secret_to_update, transaction_type);
    Ok(())
}
```

{% endtab %}
{% endtabs %}

| パラメータ              | 型                       | 必須 | デフォルト | 説明               |
| ------------------ | ----------------------- | -- | ----- | ---------------- |
| `field_type`       | `String`                | はい | ​     | 取得するフィールドの型      |
| `transaction_type` | `UpdateTransactionType` | はい | なし    | トランザクション更新のための構成 |

#### ランダムパスワードの生成

{% tabs %}
{% tab title="パスワードの生成" %}

```rust
generate_password_with_options(password_options);
```

{% endtab %}

{% tab title="パスワード生成の例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // UIDで特定のシークレットを取得する
    let secret_to_update = secrets_manager.get_secrets(["<RECORD UID>".to_string()])?;

    # ランダムなパスワードを生成
    let charset: String = "$_!?#".to_string();
    let length = 32;
    let digits = 2;
    let lowercase = 2;
    let uppercase = 2;
    let special_characters = 2;
    let password_options = PasswordOptions::new().length(length).digits(digits).lowercase(lowercase).uppercase(uppercase).special_characters(special_characters).special_characterset(charset);
    let password = generate_password_with_options(password_options).unwrap();

    # 新しいパスワードでレコードを更新
    let field_type= StandardFieldTypeEnum::PASSWORD.get_type();
    secret.set_standard_field_value_mut(field_type, password.into())?;

    # シークレットへの変更を保存
    let transaction_type: Option<UpdateTransactionType> = Some(UpdateTransactionType::None);
    secrets_manager.save(secret, transaction_type);
    Ok(())
}
```

{% endtab %}
{% endtabs %}

| パラメータ                | 型                 | 必須    | デフォルト | 説明               |
| -------------------- | ----------------- | ----- | ----- | ---------------- |
| `password_options`   | `PasswordOptions` | はい    | ​     | パスワードのための構成      |
| `charset`            | `String`          | オプション | ​     | パスワードに含める特殊文字の集合 |
| `length`             | `i32`             | オプション | 64    | パスワードの長さ         |
| `lowercase`          | `i32`             | オプション | 0     | パスワードに含める小文字の数   |
| `uppercase`          | `i32`             | オプション | 0     | パスワードに含める大文字の数   |
| `digits`             | `i32`             | オプション | 0     | パスワードに含める数字の数    |
| `special_characters` | `i32`             | オプション | 0     | パスワードに含める特殊文字の数  |

各パラメータは含める最小文字数を示します。例えば `uppercase` は大文字の最小数となります。

### ファイルのダウンロード

{% tabs %}
{% tab title="ファイルのダウンロード" %}

```rust
download_file(file_name, path);
```

{% endtab %}

{% tab title="ファイルのダウンロードの例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // UIDで特定のシークレットを取得する
    let secrets = secrets_manager.get_secrets(["<RECORD UID>".to_string()])?[0];
    // すべてのファイルを一時フォルダに保存する（フォルダが存在しない場合は作成）
    let path = format!("./temp/demo_{}.txt", secret.title);
    secret.download_file("uploaded_file.txt", &path)?;
    Ok(())
}
```

{% endtab %}
{% endtabs %}

<table><thead><tr><th>パラメータ</th><th>型</th><th>必須</th><th width="82.734375">デフォルト</th><th>説明</th></tr></thead><tbody><tr><td><code>file_name</code></td><td><code>&#x26;str</code></td><td>はい</td><td></td><td>ダウンロードするファイル名</td></tr><tr><td><code>path</code></td><td><code>&#x26;str</code></td><td>はい</td><td></td><td>保存先パス</td></tr></tbody></table>

### ファイルのアップロード

{% tabs %}
{% tab title="ファイルのアップロード" %}

```
upload_file(owner_record, keeper_file);
```

{% endtab %}

{% tab title="ファイルのアップロードの例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // UIDで特定のシークレットを取得する
    let secrets = secrets_manager.get_secrets(["<RECORD UID>".to_string()])?[0];
    // すべてのファイルを一時フォルダに保存する（フォルダが存在しない場合は作成）
    let path = format!("./temp/demo_{}.txt", secret.title);
    // アップロード用にファイルデータを準備する
    let keeper_file = KeeperFileUpload::get_file_for_upload(file_path, Some(file_name),file_title, mime_type)?;

    // 所有レコードに添付されたファイルをアップロードし、ファイルUIDを取得する
    file_uid = secrets_manager.upload_file(owner_record, keeper_file)?;
    Ok(())
}
```

{% endtab %}
{% endtabs %}

#### ファイルのアップロードのパラメータ

| パラメータ          | 型                  | 必須 | デフォルト | 説明                |
| -------------- | ------------------ | -- | ----- | ----------------- |
| `owner_record` | `Record`           | はい | なし    | ファイルをアップロードするレコード |
| `keeper_file`  | `KeeperFileUpload` | はい | ​     | アップロードするファイル      |

#### ファイルのパラメータ

| パラメータ        | 型              | 必須 | デフォルト | 説明                                                      |
| ------------ | -------------- | -- | ----- | ------------------------------------------------------- |
| `file_path`  | `&str`         | はい | ​     | アップロードするファイルのパス                                         |
| `file_name`  | `Option<&str>` | はい | ​     | アップロードするファイルの名前                                         |
| `file_title` | `Option<&str>` | はい | ​     | アップロードするファイルのタイトル                                       |
| `mime_type`  | `Option<&str>` | はい | なし    | ファイル内のデータの種類。指定がなければ `application/octet-stream` が使用されます |

#### 戻り値

型: `String`

添付ファイルのファイルUID

### シークレットの作成

#### 要件

* 共有フォルダUID
  * 共有フォルダはシークレットマネージャーアプリケーションからアクセス可能であること
  * あなたとシークレットマネージャーアプリケーションに編集権限があること
  * 共有フォルダ内に少なくとも1件のレコードがあること
* 作成するレコードとレコードフィールドが正しい形式であること
  * 各レコードタイプのフィールド形式についてこちらのページを参照
* TOTPフィールドはKSM SDK外部で生成されたURLのみ受け付けます
* レコード作成後は [upload\_file](https://github.com/Keeper-Security/gitbook-jp-secrets-manager/blob/main/secrets-manager/python-sdk/README.md#fairunoappurdo) を使って添付ファイルをアップロードできます

{% tabs %}
{% tab title="レコードの作成" %}

```rust
secrets_manager.create_secret(folder_uid, record);
```

{% endtab %}

{% tab title="ログイン情報レコードの例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    dto::{dtos::RecordCreate, field_structs::RecordField}
};
use serde_json::{self, json, Number, Value};

fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // これがRecordを作成する方法です
    let mut created_record =  RecordCreate::new("login".to_string(), "Login Record RUST_LOG_TEST".to_string(), Some("Dummy Notes".to_string()));
    
    // これが単一フィールドを作成する方法です 
    let password_field = RecordField::new_record_field_with_options("password".to_string(), Value::String(utils::generate_password()?), Some("Random password label".to_string()), false, true);

    // これはすべてのフィールドをベクターに直接作成する一例です
    let fields = vec![
        RecordField::new_record_field("login".to_string(), Value::String("login@email.com".to_string()), Some("My Custom Login lbl".to_string())),

        password_field,
     ];

    created_record.fields = Some(fields);
  
    // API呼び出しを行う
    let _ = secrets_manager.create_secret("Shared_folder_uid".to_string(), created_record)?;
    Ok(())
}
```

{% endtab %}

{% tab title="カスタムタイプの例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    dto::{dtos::RecordCreate, field_structs::RecordField}
};
use serde_json::{self, json, Number, Value};

fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // これがRecordを作成する方法です
    let mut created_record =  RecordCreate::new("login".to_string(), "Login Record RUST_LOG_TEST".to_string(), Some("Dummy Notes".to_string()));
    
    // これが単一フィールドを作成する方法です 
    let password_field = RecordField::new_record_field_with_options("password".to_string(), Value::String(utils::generate_password()?), Some("Random password label".to_string()), false, true);

    // これはJSON文字列から値オブジェクトを作成する方法の一つです
    let security_question_value = Value::from_str("{\"question\": \"What is the question?\", \"answer\": \"This is the answer!\"}")?;
    
    // これはすべてのフィールドをベクターに直接作成する一例です
    let fields = vec![
        RecordField::new_record_field("login".to_string(), Value::String("login@email.com".to_string()), Some("My Custom Login lbl".to_string())),

        RecordField::new_record_field("login".to_string(), Value::String("login@email.com".to_string()), Some("My Label".to_string())),

        password_field,
        
        RecordField::new_record_field("securityQuestion".to_string(),security_question_value , Some("My Label".to_string())),

        RecordField::new_record_field("multiline".to_string(),Value::String("This\nIs a multiline\nnote".to_string()) , Some("My Multiline lbl".to_string())),

        RecordField::new_record_field("secret".to_string(),Value::String("SecretText".to_string()) , Some("My Hidden Field lbl".to_string())),

        RecordField::new_record_field("pinCode".to_string(),Value::String("1234567890".to_string()) , Some("My Pin Code Field Lbl".to_string())),

        RecordField::new_record_field("addressRef".to_string(),Value::String("some_UID".to_string()) , Some("My Address Reference".to_string())),

        RecordField::new_record_field("phone".to_string(),json!({"region": "US", "number": "510-444-3333"}) , Some("My Phone Number".to_string())),

        RecordField::new_record_field("date".to_string(),Value::Number(Number::from(1641934793000i64)) , Some("My date".to_string())),

        RecordField::new_record_field("date".to_string(),Value::String("September eleventh two thousand and eleven".to_string()) , Some("Bad day in history of humanity".to_string())),

        RecordField::new_record_field("name".to_string(),json!({"first": "Lincoln", "last": "Adams"}) , Some("His Name".to_string())),
        ];

    // ここで標準フィールドにfieldsオブジェクトを追加しています 
    created_record.fields = Some(fields);
    
    created_record.custom = Some(
        vec![
            RecordField::new_record_field("phone".to_string(),json!({"region": "US", "number": "510-222-5555", "ext": "99887", "type": "Mobile"}) , Some("My Custom Phone Lbl".to_string())),
        ]
    );
   
    // API呼び出しを行う
    let _ = secrets_manager.create_secret("Shared_folder_uid".to_string(), created_record)?;
    Ok(())
}
```

{% endtab %}
{% endtabs %}

| パラメータ            | 型                   | 必須 | デフォルト | 説明                  |
| ---------------- | ------------------- | -- | ----- | ------------------- |
| `record_type`    | `DefaultRecordType` | はい | なし    | 作成するレコードのタイプ        |
| `title`          | `String`            | はい | ​     | 作成されたレコードのタイトル      |
| `note`           | `String`            | はい | なし    | 作成されたレコードに記載するノート   |
| `value`          | `String`            | はい | ​     | フィールドの値             |
| `label`          | `String`            | はい | なし    | フィールドのラベル           |
| `required`       | `bool`              | はい | false | フィールドが必須かどうかを定義します  |
| `privacy_screen` | `bool`              | はい | false | フィールド値を隠すかどうかを定義します |

#### 戻り値

型: `String`

新規レコードのレコードUID

### シークレットの削除

Rust KSM SDKでKeeperボルト内のレコードを削除できます

{% tabs %}
{% tab title="シークレットの削除" %}

```rust
secrets_manager.delete_secret(vec![record_uid]);
```

{% endtab %}

{% tab title="シークレットの削除例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};

fn main() -> Result<(), KSMRError> {
    // シークレットマネージャーのセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    // UIDを指定してシークレットを削除
    let secret_to_delete = secrets_manager.delete_secret(["<RECORD UID>".to_string()])?;
    Ok(())
}

```

{% endtab %}
{% endtabs %}

<table><thead><tr><th width="121.6927490234375">パラメータ</th><th width="105.942626953125">型</th><th width="107.692626953125">必須</th><th width="95.7239990234375">デフォルト</th><th>説明</th></tr></thead><tbody><tr><td><code>record_uid</code></td><td><code>String</code></td><td>はい</td><td>なし</td><td>削除対象のレコードUID</td></tr></tbody></table>

### キャッシュ

ネットワークにアクセスできなくなった場合にシークレットへのアクセスを失わないようにするため、Rust SDKではシークレットをローカルマシン上の暗号化ファイルにキャッシュできます。

#### キャッシュの設定と構成

Rust SDKでキャッシュを設定するには、`SecretsManager` オブジェクトを作成する際にキャッシュ用のポスト関数を含める必要があります。

Rust SDKには `KSMRCache` クラスに標準のキャッシュ機能が含まれており、キャッシュされたクエリをローカルファイルに保存します。これにより災害復旧の仕組みとして機能します（ネットワーク接続がある場合は常にネットワークを優先し、ウェブボルトにアクセスできない場合のみキャッシュを使用します）。

```rust
use keeper_secrets_manager_core::{core::{ClientOptions, SecretsManager}, custom_error::KSMRError, storage::FileKeyValueStorage, cache::KSMRCache};
fn main()-> Result<(), KSMRError>{
    let cache = KSMRCache::new_file_cache(Some("./cache.bin"))?;

    let token = "<Token>".to_string();

    let file_name = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
    
    let mut client_options = ClientOptions::new_client_options_with_token(token, file_name);
    client_options.set_cache(cache.into()); 
    
    let mut secrets_manager = SecretsManager::new(client_options)?;  
    let secrets = secrets_manager.get_secrets(Vec::new())?;
    for secret in secrets {
        info!("Secret: {}", secret);
    };
}
```

{% hint style="danger" %}
`KSMCache` クラスの標準キャッシュ機能は、常に最後のリクエストのみを保存します。たとえば、最初のリクエスト(R1)でUID1を正常に取得し、キャッシュが更新された場合、その後のリクエスト(R2)でUID2の取得に失敗すると、キャッシュにはUID2が含まれません。その結果、後続のUID2に関わる操作 (検索や切断など) では、キャッシュに一度も追加されていないため空のレスポンスが返されます。
{% endhint %}

{% hint style="warning" %}
キャッシュからレコードを更新する場合 (または新規レコードを作成する場合)、キャッシュされたレコードデータは無効化されるため、同じレコードに対する連続更新は失敗します。バッチ更新は異なるレコードを対象とする限り正常に動作します。キャッシュ上のレコードを更新した後は、必ず `get_secrets` 関数を呼び出してキャッシュをリフレッシュし、ボルトから新しいレコードリビジョンなどの最新メタデータを取得してください。
{% endhint %}

### フォルダ

フォルダは、作成・読み取り・更新・削除 (CRUD) の全操作に対応しています。

### フォルダの読み取り

フォルダ階層全体をダウンロードします。

{% tabs %}
{% tab title="フォルダの読み取り" %}

```rust
get_folders()
```

{% endtab %}

{% tab title="フォルダの読み取りの例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーのセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;
    
    // すべてのフォルダを取得
    let secrets = secrets_manager.ger_folders()?;
    Ok(())
}
```

{% endtab %}
{% endtabs %}

戻り値

型: `Vec<KeeperFolder>`

### フォルダの作成

`CreateOptions` とフォルダ名の指定が必要です。`CreateOptions` 内のフォルダUIDパラメータは必須で、これは共有フォルダのUIDを指します。サブフォルダのUIDは任意であり、指定されない場合は親 (共有フォルダ) 直下に通常のフォルダが新規作成されます。サブフォルダは必ずしも親共有フォルダの直接の子である必要はなく、階層を深く設定することも可能です。

{% tabs %}
{% tab title="フォルダの作成" %}

```rust
create_folder(create_options: CreateOptions, folder_name: str, folders=None)
```

{% endtab %}

{% tab title="フォルダの作成の例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーのセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    let parent_folder_uid: String = "<parent_folder_uid>".to_string();
    let sub_folder_uid: Option<String> = Option::Some((""));
    let create_options: CreateOptions = CreateOptions::new(parent_folder_uid, None);
    let new_folder_name: String = "Sample Folder 200".to_string();
    println!("Creating folder: {new_folder_name}");
    let created_folder_name = new_folder_name.clone();
    let result = secrets_manager.create_folder(create_options, new_folder_name, Vec::new())?;
    println!("Created folder {created_folder_name}");
    Ok(())
}
```

{% endtab %}
{% endtabs %}

<table><thead><tr><th width="146.0677490234375">パラメータ</th><th width="179.9166259765625">型</th><th width="105.2344970703125">必須</th><th width="97.6875">デフォルト</th><th>説明</th></tr></thead><tbody><tr><td><code>create_options</code></td><td><code>CreateOptions</code></td><td>はい</td><td>なし</td><td>親とサブフォルダのUID</td></tr><tr><td><code>folder_name</code></td><td><code>str</code></td><td>はい</td><td></td><td>フォルダ名</td></tr><tr><td><code>folders</code></td><td><code>Vec&#x3C;KeeperFolder></code></td><td>いいえ</td><td>なし</td><td>CreateOptionsの親/サブフォルダ検索に使用するフォルダ一覧</td></tr></tbody></table>

### フォルダの更新

フォルダのメタデータを更新します。現在はフォルダ名のみ更新可能です。

{% tabs %}
{% tab title="フォルダの更新" %}

```rust
secrets_manager.update_folder(folder_uid: str, folder_name: str, folders=None)
```

{% endtab %}

{% tab title="フォルダの更新の例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::InMemoryKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーのセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;

    let update_folder = secrets_manager.update_folder("<folder_uid>".to_string(),"dummy_updated_API_RUST".to_string(),Vec::new())?;
    println!("{}",(serde_json::to_string_pretty(&update_folder)?));
    Ok(())
}
```

{% endtab %}
{% endtabs %}

| パラメータ名        | 型                   | 必須  | デフォルト | 説明                        |
| ------------- | ------------------- | --- | ----- | ------------------------- |
| `folder_uid`  | `str`               | はい  |       | フォルダUID                   |
| `folder_name` | `str`               | はい  |       | 新しいフォルダ名                  |
| `folders`     | `Vec<KeeperFolder>` | いいえ | なし    | 親フォルダを検索するために使用するフォルダのリスト |

### フォルダの削除

フォルダのリストを削除します。`force_deletion` フラグで空でないフォルダも削除できます

{% hint style="info" %}
ボルトに存在しない、またはKSMアプリケーションと共有されていないフォルダUIDがあっても、エラーにはなりません。
{% endhint %}

{% hint style="info" %}
`force_deletion` を使用する場合、親フォルダとその子フォルダのUIDを同時に送信しないようにしてください。削除の順序によってはエラーが発生する可能性があります。例えば、親を削除する前に子が強制削除された場合などです。リストが常にFIFO順で処理される保証はありません。
{% endhint %}

{% tabs %}
{% tab title="フォルダの削除" %}

```rust
delete_folder(vec![“<FOLDER_UID>”.to_string()], false);
```

{% endtab %}

{% tab title="フォルダの削除の例" %}

```rust
use keeper_secrets_manager_core::{
    core::{ClientOptions, SecretsManager},
    storage::FileKeyValueStorage,
    custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
    // シークレットマネージャーをセットアップ
    let config_string = "your_base64_goes_here".to_string();
    let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
    let client_options = ClientOptions::new_client_options(config);
    let mut secrets_manager = SecretsManager::new(client_options)?;
    
    let folder_uids = vec!["folder1_uid".to_string(),"folder_2_uid".to_string()];
    secrets_manager.delete_folder(folder_uids, true)?;
    Ok(())
}
```

{% endtab %}
{% endtabs %}

| パラメータ名           | 型             | 必須  | デフォルト | 説明              |
| ---------------- | ------------- | --- | ----- | --------------- |
| `folder_uids`    | `Vec<String>` | はい  | ―     | フォルダUIDのリスト     |
| `force_deletion` | `boolean`     | いいえ | false | 空でないフォルダを強制的に削除 |