> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Formation SDK API リファレンス
各種プログラミング言語向け GS2-Formation SDK の モデルの仕様 と API のリファレンス
## モデル
### Namespace
ネームスペース
ネームスペースは、一つのプロジェクト内で同じサービスを異なる用途で複数利用するためのエンティティです。
GS2 の各サービスはネームスペース単位で管理されます。ネームスペースが異なれば、同じサービスでも完全に独立したデータ空間として扱われます。
そのため、各サービスの利用を開始するにあたってネームスペースを作成する必要があります。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024文字 | ネームスペースGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | トランザクション設定
編成操作時のトランザクションの処理方法を制御する設定です。 |
| updateMoldScript | [ScriptSetting](#scriptsetting) | | | | | フォームの保存領域のキャパシティを更新するときに実行するスクリプトの設定
Script トリガーリファレンス - [`updateMold`](../script/#updatemold) |
| updateFormScript | [ScriptSetting](#scriptsetting) | | | | | フォームを更新するときに実行するスクリプトの設定
Script トリガーリファレンス - [`updateForm`](../script/#updateform) |
| updatePropertyFormScript | [ScriptSetting](#scriptsetting) | | | | | プロパティフォームを更新するときに実行するスクリプトの設定
Script トリガーリファレンス - [`updatePropertyForm`](../script/#updatepropertyform) |
| logSetting | [LogSetting](#logsetting) | | | | | ログの出力設定
編成操作のログデータを GS2-Log に出力するための設定です。GS2-Log のネームスペースを指定することで、フォーム更新、保存領域キャパシティ変更、プロパティフォーム変更の API リクエスト・レスポンスログを収集できます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeNamespaces - ネームスペースの一覧を取得
createNamespace - ネームスペースを新規作成
getNamespace - ネームスペースを取得
updateNamespace - ネームスペースを更新
deleteNamespace - ネームスペースを削除
---
### TransactionSetting
トランザクション設定
トランザクション設定は、トランザクションの実行方法・整合性・非同期処理・競合回避の仕組みを制御する設定です。
自動実行（AutoRun）、アトミック実行（AtomicCommit）、GS2-Distributor を利用した非同期実行、スクリプト結果の一括適用、GS2-JobQueue による入手アクションの非同期化などを組み合わせ、ゲームロジックに応じた堅牢なトランザクション管理を可能にします。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| enableAutoRun | bool | | | false | | 発行したトランザクションをサーバーサイドで自動的に実行するか |
| enableAtomicCommit | bool | {enableAutoRun} == true | | false | | トランザクションの実行をアトミックにコミットするか
※ enableAutoRun が true であれば 有効 |
| transactionUseDistributor | bool | {enableAtomicCommit} == true | | false | | トランザクションを非同期処理で実行する
※ enableAtomicCommit が true であれば 有効 |
| commitScriptResultInUseDistributor | bool | {transactionUseDistributor} == true | | false | | スクリプトの結果コミット処理を非同期処理で実行するか
※ transactionUseDistributor が true であれば 有効 |
| acquireActionUseJobQueue | bool | {enableAtomicCommit} == true | | false | | 入手アクションを実行する際に GS2-JobQueue を使用するか
※ enableAtomicCommit が true であれば 有効 |
| distributorNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:distributor:default" | ~ 1024文字 | トランザクションの実行に使用する GS2-Distributor ネームスペースGRN |
| queueNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:queue:default" | ~ 1024文字 | トランザクションの実行に使用する GS2-JobQueue のネームスペースGRN |
**関連するメソッド:**
createNamespace - ネームスペースを新規作成
updateNamespace - ネームスペースを更新
**関連するモデル:**
Namespace - ネームスペース
---
### ScriptSetting
スクリプト設定
GS2 ではマイクロサービスのイベントに関連づけて、カスタムスクリプトを実行することができます。
このモデルは、スクリプトの実行をトリガーするための設定を保持します。
スクリプトの実行方式は大きく2種類あり、それは「同期実行」と「非同期実行」です。
同期実行は、スクリプトの実行が完了するまで処理がブロックされます。
代わりに、スクリプトの実行結果を使って API の実行を止めたり、API のレスポンス内容を制御することができます。
一方、非同期実行ではスクリプトの完了を待つために処理がブロックされることはありません。
ただし、スクリプトの実行結果を利用して API の実行を停止したり、API の応答内容を変更することはできません。
非同期実行は API の応答フローに影響を与えないため、原則として非同期実行を推奨します。
非同期実行には実行方式が2種類あり、GS2-Script と Amazon EventBridge があります。
Amazon EventBridge を使用することで、Lua 以外の言語で処理を記述することができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| triggerScriptId | string | | | | ~ 1024文字 | API 実行時に同期的に実行される GS2-Script のスクリプトGRN
「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。 |
| doneTriggerTargetType | 文字列列挙型
enum {
"none",
"gs2_script",
"aws"
}
| | | "none" | | 非同期スクリプトの実行方法
非同期実行で使用するスクリプトの種類を指定します。
「非同期実行のスクリプトを使用しない(none)」「GS2-Scriptを使用する(gs2_script)」「Amazon EventBridgeを使用する(aws)」が選択できます。"none": なし / "gs2_script": GS2-Script / "aws": Amazon EventBridge / |
| doneTriggerScriptId | string | {doneTriggerTargetType} == "gs2_script" | | | ~ 1024文字 | 非同期実行する GS2-Script スクリプトGRN
「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。
※ doneTriggerTargetType が "gs2_script" であれば 有効 |
| doneTriggerQueueNamespaceId | string | {doneTriggerTargetType} == "gs2_script" | | | ~ 1024文字 | 非同期実行スクリプトを実行する GS2-JobQueue ネームスペースGRN
非同期実行スクリプトを直接実行するのではなく、GS2-JobQueue を経由する場合は GS2-JobQueue のネームスペースGRN を指定します。
GS2-JobQueue を利用する理由は多くはありませんので、特に理由がなければ指定する必要はありません。
※ doneTriggerTargetType が "gs2_script" であれば 有効 |
**関連するメソッド:**
createNamespace - ネームスペースを新規作成
updateNamespace - ネームスペースを更新
**関連するモデル:**
Namespace - ネームスペース
---
### LogSetting
ログの出力設定
ログデータの出力設定を管理します。この型は、ログデータを書き出すために使用される GS2-Log ネームスペースの識別子（Namespace ID）を保持します。
ログネームスペースID(loggingNamespaceId)には、ログデータを収集し保存する GS2-Log のネームスペースを、GRNの形式で指定します。
この設定をすることで、設定されたネームスペース内で発生したAPIリクエスト・レスポンスのログデータが、対象の GS2-Log ネームスペース側へ出力されるようになります。
GS2-Log ではリアルタイムでログが提供され、システムの監視や分析、デバッグなどに利用できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| loggingNamespaceId | string | | ✓ | | ~ 1024文字 | ログを出力する GS2-Log のネームスペースGRN
「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。 |
**関連するメソッド:**
createNamespace - ネームスペースを新規作成
updateNamespace - ネームスペースを更新
**関連するモデル:**
Namespace - ネームスペース
---
### GitHubCheckoutSetting
GitHubからマスターデータをチェックアウトする設定
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| apiKeyId | string | | ✓ | | ~ 1024文字 | GitHub APIキーのGRN |
| repositoryName | string | | ✓ | | ~ 1024文字 | リポジトリ名 |
| sourcePath | string | | ✓ | | ~ 1024文字 | マスターデータ（JSON）ファイルのパス |
| referenceType | 文字列列挙型
enum {
"commit_hash",
"branch",
"tag"
}
| | ✓ | | | コードの取得元"commit_hash": コミットハッシュ / "branch": ブランチ / "tag": タグ / |
| commitHash | string | {referenceType} == "commit_hash" | ✓※ | | ~ 1024文字 | コミットハッシュ
※ referenceType が "commit_hash" であれば 必須 |
| branchName | string | {referenceType} == "branch" | ✓※ | | ~ 1024文字 | ブランチ名
※ referenceType が "branch" であれば 必須 |
| tagName | string | {referenceType} == "tag" | ✓※ | | ~ 1024文字 | タグ名
※ referenceType が "tag" であれば 必須 |
**関連するメソッド:**
updateCurrentFormMasterFromGitHub - 現在アクティブなフォームモデルのマスターデータをGitHubから更新
---
### Mold
フォームの保存領域
ゲームプレイヤーが編成した情報を保持するエンティティです。
編成情報(Form) は フォームの保存領域(Mold) ごとに複数保持することができ、いくつ保持できるかのキャパシティをゲームプレイヤー×フォームの保存領域 ごとに個別に設定できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| moldId | string | | ※ | | ~ 1024文字 | フォームの保存領域GRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | フォームの保存領域モデルの名前
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓ | | ~ 128文字 | ユーザーID |
| capacity | int | | ✓ | | 0 ~ 2147483646 | 現在のキャパシティ
この保存領域でこのプレイヤーが現在利用できるフォーム保存スロット数です。初期値は保存領域モデルの initialMaxCapacity に設定され、キャパシティ増加操作により maxCapacity まで拡張できます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeMolds - フォームの保存領域の一覧を取得
describeMoldsByUserId - ユーザーIDを指定してフォームの保存領域の一覧を取得
getMold - フォームの保存領域を取得
getMoldByUserId - ユーザーIDを指定してフォームの保存領域を取得
setMoldCapacityByUserId - ユーザーIDを指定してキャパシティサイズを設定
addMoldCapacityByUserId - ユーザーIDを指定してキャパシティサイズを加算
subMoldCapacity - キャパシティサイズを減算
subMoldCapacityByUserId - ユーザーIDを指定してキャパシティサイズを減算
deleteMold - フォームの保存領域を削除
deleteMoldByUserId - ユーザーIDを指定してフォームの保存領域を削除
getForm - フォームを取得
getFormByUserId - ユーザーIDを指定してフォームを取得
getFormWithSignature - 署名付きフォームを取得
getFormWithSignatureByUserId - ユーザーIDを指定して署名付きフォームを取得
setForm - フォームを設定
setFormByUserId - ユーザーIDを指定してフォームを設定
setFormWithSignature - 署名付きスロットを使ってフォームを更新
acquireActionsToFormProperties - ユーザーIDを指定してフォームのプロパティに入手アクションを適用
deleteForm - フォームを削除
deleteFormByUserId - ユーザーIDを指定してフォームを削除
---
### Form
フォーム
フォームは編成状況を表すエンティティです。
編成できる領域として `スロット` を定義できます。
武器・防具 であれば 「右手」「左手」「胴」「腕」のような部位をスロットとし、
パーティであれば「前衛」「中衛」「後衛」のようなポジションをスロットとして表現できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| formId | string | | ※ | | ~ 1024文字 | フォームGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | フォーム名
このフォームが属する保存領域モデルの名前です。このフォームインスタンスに適用されるフォームモデル（スロット構成）を識別します。 |
| index | int | | ✓ | | 0 ~ 2147483646 | フォームのインデックス
保存領域内でこのフォームが占める保存スロットを識別するゼロベースのインデックスです。最大インデックスは保存領域の現在のキャパシティによって制限されます。例えば、インデックス 0 が「パーティ1」、インデックス 1 が「パーティ2」のように使用できます。 |
| slots | [List<Slot>](#slot) | | | | 0 ~ 10 items | スロットリスト
このフォームの現在のスロット割り当てです。各エントリはフォームモデルで定義されたスロットに対応し、そのポジションに割り当てられたリソースのプロパティ ID を保持します。スロット名はフォームモデルで定義されたものと一致する必要があります。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeForms - フォームの一覧を取得
describeFormsByUserId - ユーザーIDを指定してフォームの一覧を取得
getForm - フォームを取得
getFormByUserId - ユーザーIDを指定してフォームを取得
getFormWithSignature - 署名付きフォームを取得
getFormWithSignatureByUserId - ユーザーIDを指定して署名付きフォームを取得
setForm - フォームを設定
setFormByUserId - ユーザーIDを指定してフォームを設定
setFormWithSignature - 署名付きスロットを使ってフォームを更新
acquireActionsToFormProperties - ユーザーIDを指定してフォームのプロパティに入手アクションを適用
deleteForm - フォームを削除
deleteFormByUserId - ユーザーIDを指定してフォームを削除
---
### PropertyForm
プロパティフォーム
プロパティフォームは編成状況を表すエンティティです。
Mold / Form との違いは、スロット数を定義して、各スロットに編成を記録するのが Mold / Form で、
所有している装備に対してスキルを設定するような、数を事前に決めるのが難しい編成を表現するのに利用するのがプロパティフォームです。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| formId | string | | ※ | | ~ 1024文字 | プロパティフォームGRN
※ サーバーが自動で設定 |
| userId | string | | ✓ | | ~ 128文字 | ユーザーID |
| name | string | | ✓ | | ~ 128文字 | プロパティフォーム名
このプロパティフォームのスロット構成を定義するプロパティフォームモデルの名前です。割り当て可能なスロットを決定します。 |
| propertyId | string | | ✓ | | ~ 1024文字 | プロパティID
このプロパティフォームインスタンスを一意に識別する開発者定義の識別子です。通常、このフォームが設定する所有リソース（例: GS2-Inventory のアイテムセット）の GRN を設定します。特定の装備にスキルを設定するような用途で使用されます。 |
| slots | [List<Slot>](#slot) | | | | 0 ~ 10 items | スロットリスト
このプロパティフォームの現在のスロット割り当てです。各エントリはプロパティフォームモデルで定義されたスロットに対応します。例えば、プロパティフォームが装備のスキル設定を表す場合、各スロットは異なるスキル割り当てを保持します。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describePropertyForms - プロパティフォームの一覧を取得
describePropertyFormsByUserId - ユーザーIDを指定してプロパティフォームの一覧を取得
getPropertyForm - プロパティフォームを取得
getPropertyFormByUserId - ユーザーIDを指定してプロパティフォームを取得
getPropertyFormWithSignature - 署名付きプロパティフォームを取得
getPropertyFormWithSignatureByUserId - ユーザーIDを指定して署名付きプロパティフォームを取得
setPropertyForm - プロパティフォームを更新
setPropertyFormByUserId - ユーザーIDを指定してプロパティフォームを更新
setPropertyFormWithSignature - 署名付きスロットを使ってプロパティフォームを更新
acquireActionsToPropertyFormProperties - プロパティフォームのプロパティに入手アクションを適用
deletePropertyForm - プロパティフォームを削除
deletePropertyFormByUserId - ユーザーIDを指定してプロパティフォームを削除
---
### FormModel
フォームモデル
フォームモデルは編成状況を表すエンティティです。
編成できる領域として `スロット` を定義できます。
武器・防具 であれば 「右手」「左手」「胴」「腕」のような部位をスロットとし、
パーティであれば「前衛」「中衛」「後衛」のようなポジションをスロットとして表現できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| formModelId | string | | ※ | | ~ 1024文字 | フォームモデルGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | フォームモデル名
フォームモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| slots | [List<SlotModel>](#slotmodel) | | ✓ | | 1 ~ 10 items | スロットモデルリスト
このフォームを構成するスロット定義の順序付きリストです。各スロットは割り当て可能なポジションを表し、スロット名はフォーム内で一意である必要があります。装備では「weapon」「armor」「accessory」のようなスロット、パーティでは「position_1」「position_2」のようなスロットが考えられます。 |
**関連するメソッド:**
getForm - フォームを取得
getFormByUserId - ユーザーIDを指定してフォームを取得
getFormWithSignature - 署名付きフォームを取得
getFormWithSignatureByUserId - ユーザーIDを指定して署名付きフォームを取得
setForm - フォームを設定
setFormByUserId - ユーザーIDを指定してフォームを設定
setFormWithSignature - 署名付きスロットを使ってフォームを更新
deleteForm - フォームを削除
deleteFormByUserId - ユーザーIDを指定してフォームを削除
getFormModel - フォームモデルを取得
**関連するモデル:**
MoldModel - フォームの保存領域モデル
---
### MoldModel
フォームの保存領域モデル
フォームの保存領域モデルは、パーティ編成であれば「火属性パーティ」「水属性パーティ」のような形で保存することを想定しています。
保存できる領域の数は制限することができ、個別に拡張することもできます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| moldModelId | string | | ※ | | ~ 1024文字 | フォームの保存領域GRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | フォームの保存領域モデルの名前
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| initialMaxCapacity | int | | ✓ | | 1 ~ 2147483646 | フォームを保存できる初期キャパシティ
この保存領域で各プレイヤーが利用できるデフォルトのフォーム保存スロット数です。例えば 3 に設定すると、プレイヤーは初期状態で最大 3 つの異なる編成（例:「火属性パーティ」「水属性パーティ」「風属性パーティ」）を保存できます。プレイヤーごとに maxCapacity まで拡張可能です。 |
| maxCapacity | int | | ✓ | | 1 ~ 2147483646 | フォームを保存できる最大キャパシティ
この保存領域でプレイヤーごとのフォーム保存スロット数の絶対的な上限です。キャパシティ拡張操作を行っても、キャパシティはこの値を超えることはできません。initialMaxCapacity 以上の値である必要があります。 |
| formModel | [FormModel](#formmodel) | | ✓ | | | フォームモデル |
**関連するメソッド:**
getMold - フォームの保存領域を取得
getMoldByUserId - ユーザーIDを指定してフォームの保存領域を取得
setMoldCapacityByUserId - ユーザーIDを指定してキャパシティサイズを設定
addMoldCapacityByUserId - ユーザーIDを指定してキャパシティサイズを加算
subMoldCapacity - キャパシティサイズを減算
subMoldCapacityByUserId - ユーザーIDを指定してキャパシティサイズを減算
getForm - フォームを取得
getFormByUserId - ユーザーIDを指定してフォームを取得
getFormWithSignature - 署名付きフォームを取得
getFormWithSignatureByUserId - ユーザーIDを指定して署名付きフォームを取得
setForm - フォームを設定
setFormByUserId - ユーザーIDを指定してフォームを設定
setFormWithSignature - 署名付きスロットを使ってフォームを更新
deleteForm - フォームを削除
deleteFormByUserId - ユーザーIDを指定してフォームを削除
describeMoldModels - フォームの保存領域モデルの一覧を取得
getMoldModel - フォームの保存領域モデルを取得
---
### PropertyFormModel
プロパティフォームモデル
プロパティフォームモデルは編成状況を表すエンティティです。
Mold / Form との違いは、スロット数を定義して、各スロットに編成を記録するのが Mold / Form で、
所有している装備に対してスキルを設定するような、数を事前に決めるのが難しい編成を表現するのに利用するのがプロパティフォームモデルです。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| propertyFormModelId | string | | ※ | | ~ 1024文字 | プロパティフォームモデルGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | プロパティフォームモデル名
プロパティフォームモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| slots | [List<SlotModel>](#slotmodel) | | ✓ | | 1 ~ 10 items | スロットモデルリスト
このプロパティフォームのスロット定義の順序付きリストです。キャパシティでフォーム数が制限される Mold/Form とは異なり、プロパティフォームはプロパティ ID で識別され、所有するリソースごとに存在できます。スロット名はフォーム内で一意である必要があります。 |
**関連するメソッド:**
getPropertyForm - プロパティフォームを取得
getPropertyFormByUserId - ユーザーIDを指定してプロパティフォームを取得
getPropertyFormWithSignature - 署名付きプロパティフォームを取得
getPropertyFormWithSignatureByUserId - ユーザーIDを指定して署名付きプロパティフォームを取得
setPropertyForm - プロパティフォームを更新
setPropertyFormByUserId - ユーザーIDを指定してプロパティフォームを更新
setPropertyFormWithSignature - 署名付きスロットを使ってプロパティフォームを更新
deletePropertyForm - プロパティフォームを削除
deletePropertyFormByUserId - ユーザーIDを指定してプロパティフォームを削除
describePropertyFormModels - プロパティフォームモデルの一覧を取得
getPropertyFormModel - プロパティフォームモデルを取得
---
### SlotModel
スロットモデル
フォームモデル内の1つのスロットを定義します。スロットはゲームリソース（アイテム、キャラクター、装備など）を配置できる割り当て可能なポジションを表します。プロパティの正規表現によってスロットに設定可能な値が検証されます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | スロットモデル名
フォームモデル内でこのスロットを一意に識別する名前です。装備フォームでは「right_hand」「body」のような名前が、パーティフォームでは「vanguard」「rear_guard」のような名前が一般的です。 |
| propertyRegex | string | | | ".*" | ~ 512文字 | プロパティとして設定可能な値の正規表現
このスロットに割り当て可能なプロパティ ID 値を検証する正規表現パターンです。例えば、特定の GS2-Inventory アイテム GRN や GS2-Dictionary エントリー GRN に制限することができます。デフォルトは ".*" で任意の値を許可します。 |
| metadata | string | | | | ~ 512文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
**関連するモデル:**
FormModel - フォームモデル
PropertyFormModel - プロパティフォームモデル
FormModelMaster - フォームモデルマスター
PropertyFormModelMaster - プロパティフォームモデルマスター
---
### Slot
スロット
フォーム内の1つのスロットの実際の割り当て状態を表します。各スロットは、プレイヤーがそのポジションに配置したゲームリソース（GS2-Inventory のアイテムセットや GS2-Dictionary のエントリーなど）を参照するプロパティ ID を保持します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | スロットモデル名
フォームモデル内でこのスロットを一意に識別する名前です。装備フォームでは「right_hand」「body」のような名前が、パーティフォームでは「vanguard」「rear_guard」のような名前が一般的です。 |
| propertyId | string | | | | ~ 1024文字 | プロパティID
このスロットに割り当てられたゲームリソースを参照する開発者定義の識別子です。通常、GS2-Inventory のアイテムセット GRN、GS2-Dictionary のエントリー GRN、またはその他のリソース識別子です。スロットモデルの propertyRegex パターンに一致する必要があります。 |
| metadata | string | | | | ~ 1024文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
**関連するモデル:**
Form - フォーム
PropertyForm - プロパティフォーム
---
### SlotWithSignature
署名付きスロット
プレイヤーが参照するリソースを所有していることを証明する暗号署名を含むスロット割り当てです。フォーム更新時に、プレイヤーがスロットに配置するアイテム、エントリー、またはその他のリソースを実際に所有していることを検証し、不正な割り当てを防止するために使用されます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | スロットモデル名
スロットモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| propertyType | 文字列列挙型
enum {
"gs2_inventory",
"gs2_simple_inventory",
"gs2_dictionary"
}
| | ✓ | | | プロパティの種類
このスロットが参照する GS2 リソースの種類を指定します。署名の検証方法を決定します。GS2-Inventory のアイテムセット、GS2-Inventory のシンプルアイテム、GS2-Dictionary のエントリーはそれぞれ異なる署名形式を持ちます。"gs2_inventory": GS2-Inventory::ItemSet / "gs2_simple_inventory": GS2-Inventory::SimpleItem / "gs2_dictionary": GS2-Dictionary::Entry / |
| body | string | | | | ~ 1048576文字 | ペイロード
リソースを所有する GS2 サービスから取得したシリアライズされたリソースデータです。署名を検証し所有権を確認するために必要なリソース状態情報を含みます。 |
| signature | string | | | | ~ 1024文字 | プロパティIDが指すリソースを所有していることを証明する署名
リソースを所有する GS2 サービスによって生成された暗号署名です。フォーム更新時に、プレイヤーが参照するアイテムセット、シンプルアイテム、またはディクショナリエントリーを所有していることを確認するために検証されます。 |
| metadata | string | | | | ~ 1024文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
---
### AcquireAction
入手アクション
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 入手アクションで実行するアクションの種類 |
| request | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
**関連するメソッド:**
acquireActionsToFormProperties - ユーザーIDを指定してフォームのプロパティに入手アクションを適用
acquireActionsToPropertyFormProperties - プロパティフォームのプロパティに入手アクションを適用
---
### Config
コンフィグ設定
トランザクションの変数に適用する設定値
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| key | string | | ✓ | | ~ 64文字 | 名前 |
| value | string | | | | ~ 51200文字 | 値 |
---
### VerifyActionResult
検証アクションの実行結果
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 検証アクションで実行するアクションの種類 |
| verifyRequest | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
| statusCode | int | | | | 0 ~ 999 | ステータスコード |
| verifyResult | string | | | | ~ 1048576文字 | 結果内容 |
**関連するモデル:**
TransactionResult - トランザクション実行結果
---
### ConsumeActionResult
消費アクションの実行結果
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 消費アクションで実行するアクションの種類 |
| consumeRequest | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
| statusCode | int | | | | 0 ~ 999 | ステータスコード |
| consumeResult | string | | | | ~ 1048576文字 | 結果内容 |
**関連するモデル:**
TransactionResult - トランザクション実行結果
---
### AcquireActionResult
入手アクションの実行結果
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 入手アクションで実行するアクションの種類 |
| acquireRequest | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
| statusCode | int | | | | 0 ~ 999 | ステータスコード |
| acquireResult | string | | | | ~ 1048576文字 | 結果内容 |
**関連するモデル:**
TransactionResult - トランザクション実行結果
---
### TransactionResult
トランザクション実行結果
サーバーサイドでのトランザクションの自動実行機能を利用して実行されたトランザクションの実行結果
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| transactionId | string | | ✓ | | 36 ~ 36文字 | トランザクションID |
| verifyResults | [List<VerifyActionResult>](#verifyactionresult) | | | | 0 ~ 10 items | 検証アクションの実行結果リスト |
| consumeResults | [List<ConsumeActionResult>](#consumeactionresult) | | | [] | 0 ~ 10 items | 消費アクションの実行結果リスト |
| acquireResults | [List<AcquireActionResult>](#acquireactionresult) | | | [] | 0 ~ 100 items | 入手アクションの実行結果リスト |
| hasError | bool | | | false | | トランザクション実行中にエラーが発生したかどうか |
**関連するメソッド:**
acquireActionsToFormProperties - ユーザーIDを指定してフォームのプロパティに入手アクションを適用
acquireActionsToPropertyFormProperties - プロパティフォームのプロパティに入手アクションを適用
---
### CurrentFormMaster
現在アクティブなフォームモデルのマスターデータ
現在ネームスペース内で有効な、フォームモデルの定義を記述したマスターデータです。
GS2ではマスターデータの管理にJSON形式のファイルを使用します。
ファイルをアップロードすることで、実際にサーバーに設定を反映することができます。
JSONファイルを作成する方法として、マネージメントコンソール内にマスターデータエディタを提供しています。
また、よりゲームの運営に相応しいツールを作成し、適切なフォーマットのJSONファイルを書き出すことでもサービスを利用可能です。
{{% alert title="Note" color="info" %}}
JSONファイルの形式については [GS2-Formation マスターデータリファレンス](api_reference/formation/master_data/) をご参照ください。
{{% /alert %}}
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024文字 | ネームスペースGRN
※ サーバーが自動で設定 |
| settings | string | | ✓ | | ~ 5242880 バイト (5MB) | マスターデータ |
**関連するメソッド:**
exportMaster - フォームモデルマスターを有効化可能なマスターデータ形式でエクスポート
getCurrentFormMaster - 現在アクティブなフォームモデルのマスターデータを取得
updateCurrentFormMaster - 現在アクティブなフォームモデルのマスターデータを更新
updateCurrentFormMasterFromGitHub - 現在アクティブなフォームモデルのマスターデータをGitHubから更新
---
### FormModelMaster
フォームモデルマスター
フォームモデルマスターは、ゲーム内で使用されるフォームモデルの編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。
インポート・更新処理を行うことで、実際にゲームから参照されるフォームモデルとして反映されます。
フォームモデルは編成状況を表すエンティティです。
編成できる領域として `スロット` を定義できます。
武器・防具 であれば 「右手」「左手」「胴」「腕」のような部位をスロットとし、
パーティであれば「前衛」「中衛」「後衛」のようなポジションをスロットとして表現できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| formModelId | string | | ※ | | ~ 1024文字 | フォームモデルマスターGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | フォームモデル名
フォームモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| slots | [List<SlotModel>](#slotmodel) | | ✓ | | 1 ~ 10 items | スロットモデルリスト
このフォームを構成するスロット定義の順序付きリストです。各スロットは割り当て可能なポジションを表し、スロット名はフォーム内で一意である必要があります。装備では「weapon」「armor」「accessory」のようなスロット、パーティでは「position_1」「position_2」のようなスロットが考えられます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeFormModelMasters - フォームモデルマスターの一覧を取得
createFormModelMaster - フォームモデルマスターを新規作成
getFormModelMaster - フォームモデルマスターを取得
updateFormModelMaster - フォームモデルマスターを更新
deleteFormModelMaster - フォームモデルマスターを削除
---
### MoldModelMaster
フォームの保存領域モデルマスター
フォームの保存領域モデルマスターは、ゲーム内で使用されるフォームの保存領域モデルの編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。
インポート・更新処理を行うことで、実際にゲームから参照されるフォームの保存領域モデルとして反映されます。
フォームの保存領域モデルは、パーティ編成であれば「火属性パーティ」「水属性パーティ」のような形で保存することを想定しています。
保存できる領域の数は制限することができ、個別に拡張することもできます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| moldModelId | string | | ※ | | ~ 1024文字 | フォームの保存領域モデルマスターGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | フォームの保存領域モデル名
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| initialMaxCapacity | int | | ✓ | | 1 ~ 2147483646 | フォームを保存できる初期キャパシティ
この保存領域で各プレイヤーが利用できるデフォルトのフォーム保存スロット数です。例えば 3 に設定すると、プレイヤーは初期状態で最大 3 つの異なる編成（例:「火属性パーティ」「水属性パーティ」「風属性パーティ」）を保存できます。プレイヤーごとに maxCapacity まで拡張可能です。 |
| maxCapacity | int | | ✓ | | 1 ~ 2147483646 | フォームを保存できる最大キャパシティ
この保存領域でプレイヤーごとのフォーム保存スロット数の絶対的な上限です。キャパシティ拡張操作を行っても、キャパシティはこの値を超えることはできません。initialMaxCapacity 以上の値である必要があります。 |
| formModelName | string | | ✓ | | ~ 128文字 | フォームモデル名 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeMoldModelMasters - フォームの保存領域マスターの一覧を取得
createMoldModelMaster - フォームの保存領域マスターを新規作成
getMoldModelMaster - フォームの保存領域マスターを取得
updateMoldModelMaster - フォームの保存領域マスターを更新
deleteMoldModelMaster - フォームの保存領域マスターを削除
---
### PropertyFormModelMaster
プロパティフォームモデルマスター
プロパティフォームモデルマスターは、ゲーム内で使用されるプロパティフォームモデルの編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。
インポート・更新処理を行うことで、実際にゲームから参照されるプロパティフォームモデルとして反映されます。
プロパティフォームモデルは編成状況を表すエンティティです。
Mold / Form との違いは、スロット数を定義して、各スロットに編成を記録するのが Mold / Form で、
所有している装備に対してスキルを設定するような、数を事前に決めるのが難しい編成を表現するのに利用するのがプロパティフォームモデルです。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| propertyFormModelId | string | | ※ | | ~ 1024文字 | プロパティフォームモデルマスターGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | プロパティフォームモデル名
プロパティフォームモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| slots | [List<SlotModel>](#slotmodel) | | ✓ | | 1 ~ 10 items | スロットモデルリスト
このプロパティフォームのスロット定義の順序付きリストです。キャパシティでフォーム数が制限される Mold/Form とは異なり、プロパティフォームはプロパティ ID で識別され、所有するリソースごとに存在できます。スロット名はフォーム内で一意である必要があります。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describePropertyFormModelMasters - プロパティフォームモデルマスターの一覧を取得
createPropertyFormModelMaster - プロパティフォームモデルマスターを新規作成
getPropertyFormModelMaster - プロパティフォームモデルマスターを取得
updatePropertyFormModelMaster - プロパティフォームモデルマスターを更新
deletePropertyFormModelMaster - プロパティフォームモデルマスターを削除
---
## メソッド
### describeNamespaces
ネームスペースの一覧を取得
プロジェクト内において、サービス単位で作成されたネームスペースの一覧を取得します。
オプションのページトークンを使用して、リストの特定の位置からデータの取得を開始できます。
また、取得するネームスペースの数を制限することも可能です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namePrefix | string | | | | ~ 64文字 | ネームスペース名のフィルター接頭辞 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Namespace>](#namespace) | ネームスペースのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&formation.DescribeNamespacesRequest {
NamePrefix: nil,
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->describeNamespaces(
(new DescribeNamespacesRequest())
->withNamePrefix(null)
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.DescribeNamespacesRequest;
import io.gs2.formation.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
DescribeNamespacesResult result = client.describeNamespaces(
new DescribeNamespacesRequest()
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2Formation.Request.DescribeNamespacesRequest()
.WithNamePrefix(null)
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2Formation.DescribeNamespacesRequest()
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.describe_namespaces(
formation.DescribeNamespacesRequest()
.with_name_prefix(None)
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.describe_namespaces({
namePrefix=nil,
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.describe_namespaces_async({
namePrefix=nil,
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createNamespace
ネームスペースを新規作成
ネームスペースの名前、説明、および各種設定を含む詳細情報を指定する必要があります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | トランザクション設定
編成操作時のトランザクションの処理方法を制御する設定です。 |
| updateMoldScript | [ScriptSetting](#scriptsetting) | | | | | フォームの保存領域のキャパシティを更新するときに実行するスクリプトの設定
Script トリガーリファレンス - [`updateMold`](../script/#updatemold) |
| updateFormScript | [ScriptSetting](#scriptsetting) | | | | | フォームを更新するときに実行するスクリプトの設定
Script トリガーリファレンス - [`updateForm`](../script/#updateform) |
| updatePropertyFormScript | [ScriptSetting](#scriptsetting) | | | | | プロパティフォームを更新するときに実行するスクリプトの設定
Script トリガーリファレンス - [`updatePropertyForm`](../script/#updatepropertyform) |
| logSetting | [LogSetting](#logsetting) | | | | | ログの出力設定
編成操作のログデータを GS2-Log に出力するための設定です。GS2-Log のネームスペースを指定することで、フォーム更新、保存領域キャパシティ変更、プロパティフォーム変更の API リクエスト・レスポンスログを収集できます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 作成したネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&formation.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
TransactionSetting: &formation.TransactionSetting{
EnableAutoRun: pointy.Bool(false),
QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"),
},
UpdateMoldScript: nil,
UpdateFormScript: nil,
UpdatePropertyFormScript: nil,
LogSetting: &formation.LogSetting{
LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting((new \Gs2\Formation\Model\TransactionSetting())
->withEnableAutoRun(false)
->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
->withUpdateMoldScript(null)
->withUpdateFormScript(null)
->withUpdatePropertyFormScript(null)
->withLogSetting((new \Gs2\Formation\Model\LogSetting())
->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.CreateNamespaceRequest;
import io.gs2.formation.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(new io.gs2.formation.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.withUpdateMoldScript(null)
.withUpdateFormScript(null)
.withUpdatePropertyFormScript(null)
.withLogSetting(new io.gs2.formation.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2Formation.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(new Gs2.Gs2Formation.Model.TransactionSetting()
.WithEnableAutoRun(false)
.WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.WithUpdateMoldScript(null)
.WithUpdateFormScript(null)
.WithUpdatePropertyFormScript(null)
.WithLogSetting(new Gs2.Gs2Formation.Model.LogSetting()
.WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.createNamespace(
new Gs2Formation.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(new Gs2Formation.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.withUpdateMoldScript(null)
.withUpdateFormScript(null)
.withUpdatePropertyFormScript(null)
.withLogSetting(new Gs2Formation.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.create_namespace(
formation.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_transaction_setting(
formation.TransactionSetting()
.with_enable_auto_run(False)
.with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001'))
.with_update_mold_script(None)
.with_update_form_script(None)
.with_update_property_form_script(None)
.with_log_setting(
formation.LogSetting()
.with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
},
updateMoldScript=nil,
updateFormScript=nil,
updatePropertyFormScript=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
},
updateMoldScript=nil,
updateFormScript=nil,
updatePropertyFormScript=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getNamespaceStatus
ネームスペースの状態を取得
指定されたネームスペースの現在の状態を取得します。
これには、ネームスペースがアクティブか、保留中か、またはその他の状態にあるかが含まれます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| status | string | |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&formation.GetNamespaceStatusRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
status := result.Status
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->getNamespaceStatus(
(new GetNamespaceStatusRequest())
->withNamespaceName("namespace-0001")
);
$status = $result->getStatus();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.GetNamespaceStatusRequest;
import io.gs2.formation.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
GetNamespaceStatusResult result = client.getNamespaceStatus(
new GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
String status = result.getStatus();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2Formation.Request.GetNamespaceStatusRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var status = result.Status;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2Formation.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.get_namespace_status(
formation.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.get_namespace_status({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
status = result.status;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.get_namespace_status_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
status = result.status;
```
---
### getNamespace
ネームスペースを取得
指定されたネームスペースの詳細情報を取得します。
これには、ネームスペースの名前、説明、およびその他の設定情報が含まれます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | ネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&formation.GetNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->getNamespace(
(new GetNamespaceRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.GetNamespaceRequest;
import io.gs2.formation.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
GetNamespaceResult result = client.getNamespace(
new GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2Formation.Request.GetNamespaceRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.getNamespace(
new Gs2Formation.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.get_namespace(
formation.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.get_namespace({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.get_namespace_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateNamespace
ネームスペースを更新
指定されたネームスペースの設定を更新します。
ネームスペースの説明や、特定の設定を変更することができます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | トランザクション設定
編成操作時のトランザクションの処理方法を制御する設定です。 |
| updateMoldScript | [ScriptSetting](#scriptsetting) | | | | | フォームの保存領域のキャパシティを更新するときに実行するスクリプトの設定
Script トリガーリファレンス - [`updateMold`](../script/#updatemold) |
| updateFormScript | [ScriptSetting](#scriptsetting) | | | | | フォームを更新するときに実行するスクリプトの設定
Script トリガーリファレンス - [`updateForm`](../script/#updateform) |
| updatePropertyFormScript | [ScriptSetting](#scriptsetting) | | | | | プロパティフォームを更新するときに実行するスクリプトの設定
Script トリガーリファレンス - [`updatePropertyForm`](../script/#updatepropertyform) |
| logSetting | [LogSetting](#logsetting) | | | | | ログの出力設定
編成操作のログデータを GS2-Log に出力するための設定です。GS2-Log のネームスペースを指定することで、フォーム更新、保存領域キャパシティ変更、プロパティフォーム変更の API リクエスト・レスポンスログを収集できます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 更新したネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&formation.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
TransactionSetting: &formation.TransactionSetting{
EnableAutoRun: pointy.Bool(false),
QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"),
},
UpdateMoldScript: nil,
UpdateFormScript: nil,
UpdatePropertyFormScript: nil,
LogSetting: &formation.LogSetting{
LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting((new \Gs2\Formation\Model\TransactionSetting())
->withEnableAutoRun(false)
->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
->withUpdateMoldScript(null)
->withUpdateFormScript(null)
->withUpdatePropertyFormScript(null)
->withLogSetting((new \Gs2\Formation\Model\LogSetting())
->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.UpdateNamespaceRequest;
import io.gs2.formation.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(new io.gs2.formation.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.withUpdateMoldScript(null)
.withUpdateFormScript(null)
.withUpdatePropertyFormScript(null)
.withLogSetting(new io.gs2.formation.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2Formation.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(new Gs2.Gs2Formation.Model.TransactionSetting()
.WithEnableAutoRun(false)
.WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.WithUpdateMoldScript(null)
.WithUpdateFormScript(null)
.WithUpdatePropertyFormScript(null)
.WithLogSetting(new Gs2.Gs2Formation.Model.LogSetting()
.WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2Formation.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(new Gs2Formation.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.withUpdateMoldScript(null)
.withUpdateFormScript(null)
.withUpdatePropertyFormScript(null)
.withLogSetting(new Gs2Formation.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.update_namespace(
formation.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_transaction_setting(
formation.TransactionSetting()
.with_enable_auto_run(False)
.with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002'))
.with_update_mold_script(None)
.with_update_form_script(None)
.with_update_property_form_script(None)
.with_log_setting(
formation.LogSetting()
.with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
},
updateMoldScript=nil,
updateFormScript=nil,
updatePropertyFormScript=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
},
updateMoldScript=nil,
updateFormScript=nil,
updatePropertyFormScript=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteNamespace
ネームスペースを削除
指定されたネームスペースを削除します。
この操作は不可逆であり、削除されたネームスペースに関連するすべてのデータは回復不能になります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 削除したネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&formation.DeleteNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->deleteNamespace(
(new DeleteNamespaceRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.DeleteNamespaceRequest;
import io.gs2.formation.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
DeleteNamespaceResult result = client.deleteNamespace(
new DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2Formation.Request.DeleteNamespaceRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2Formation.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.delete_namespace(
formation.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.delete_namespace({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.delete_namespace_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getServiceVersion
マイクロサービスのバージョンを取得
#### Request
リクエストパラメータ: なし
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | string | バージョン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&formation.GetServiceVersionRequest {
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->getServiceVersion(
(new GetServiceVersionRequest())
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.GetServiceVersionRequest;
import io.gs2.formation.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
GetServiceVersionResult result = client.getServiceVersion(
new GetServiceVersionRequest()
);
String item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2Formation.Request.GetServiceVersionRequest(),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2Formation.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.get_service_version(
formation.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.get_service_version({
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.get_service_version_async({
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### dumpUserDataByUserId
指定したユーザーIDに紐づくデータのダンプを取得
個人情報保護の法的要件を満たすために使用したり、データのバックアップや移行に使用できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&formation.DumpUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->dumpUserDataByUserId(
(new DumpUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.DumpUserDataByUserIdRequest;
import io.gs2.formation.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
DumpUserDataByUserIdResult result = client.dumpUserDataByUserId(
new DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2Formation.Request.DumpUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2Formation.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.dump_user_data_by_user_id(
formation.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.dump_user_data_by_user_id({
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.dump_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### checkDumpUserDataByUserId
指定したユーザーIDに紐づくデータのダンプが完了しているか確認
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| url | string | 出力データのURL |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&formation.CheckDumpUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
url := result.Url
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->checkDumpUserDataByUserId(
(new CheckDumpUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$url = $result->getUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.formation.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
CheckDumpUserDataByUserIdResult result = client.checkDumpUserDataByUserId(
new CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
String url = result.getUrl();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2Formation.Request.CheckDumpUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var url = result.Url;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2Formation.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
formation.CheckDumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
url = result.url
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.check_dump_user_data_by_user_id({
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
url = result.url;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.check_dump_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
url = result.url;
```
---
### cleanUserDataByUserId
ユーザーデータの完全削除
指定されたユーザーIDに紐づくデータのクリーニングを実行します。
これにより、特定のユーザーデータをプロジェクトから安全に削除できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&formation.CleanUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->cleanUserDataByUserId(
(new CleanUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.CleanUserDataByUserIdRequest;
import io.gs2.formation.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
CleanUserDataByUserIdResult result = client.cleanUserDataByUserId(
new CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2Formation.Request.CleanUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2Formation.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.clean_user_data_by_user_id(
formation.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.clean_user_data_by_user_id({
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.clean_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### checkCleanUserDataByUserId
指定したユーザーIDのユーザーデータの完全削除が完了しているか確認
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&formation.CheckCleanUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->checkCleanUserDataByUserId(
(new CheckCleanUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.formation.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
CheckCleanUserDataByUserIdResult result = client.checkCleanUserDataByUserId(
new CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2Formation.Request.CheckCleanUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2Formation.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
formation.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.check_clean_user_data_by_user_id({
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.check_clean_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### prepareImportUserDataByUserId
指定したユーザーIDに紐づくデータのインポートを準備
インポートに使用できるデータは GS2 によってエクスポートして取得したデータに限定され、古いデータはインポートに失敗する可能性があります。
エクスポートしたユーザーIDと異なるユーザーIDでインポートすることができますが、ユーザーデータのペイロード内にユーザーIDが含まれる場合はその限りではありません。
このAPIの戻り値で応答されたURLにエクスポートした zip ファイルをアップロードし、importUserDataByUserId を呼び出すことで実際のインポート処理を開始できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| uploadToken | string | アップロード後に結果を反映する際に使用するトークン |
| uploadUrl | string | ユーザーデータアップロード処理の実行に使用するURL |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&formation.PrepareImportUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->prepareImportUserDataByUserId(
(new PrepareImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$uploadToken = $result->getUploadToken();
$uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.formation.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
PrepareImportUserDataByUserIdResult result = client.prepareImportUserDataByUserId(
new PrepareImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
String uploadToken = result.getUploadToken();
String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2Formation.Request.PrepareImportUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var uploadUrl = result.UploadUrl;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2Formation.PrepareImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const uploadToken = result.getUploadToken();
const uploadUrl = result.getUploadUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
formation.PrepareImportUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
upload_token = result.upload_token
upload_url = result.upload_url
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.prepare_import_user_data_by_user_id({
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.prepare_import_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
---
### importUserDataByUserId
指定したユーザーIDに紐づくデータのインポートを実行
インポートに使用できるデータは GS2 によってエクスポートして取得したデータに限定され、古いデータはインポートに失敗する可能性があります。
エクスポートしたユーザーIDと異なるユーザーIDでインポートすることができますが、ユーザーデータのペイロード内にユーザーIDが含まれる場合はその限りではありません。
このAPIを呼び出す前に prepareImportUserDataByUserId を呼び出して、アップロード準備を完了させる必要があります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| uploadToken | string | | ✓| | ~ 1024文字 | アップロード準備で受け取ったトークン |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&formation.ImportUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
UploadToken: pointy.String("upload-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->importUserDataByUserId(
(new ImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withUploadToken("upload-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.ImportUserDataByUserIdRequest;
import io.gs2.formation.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
ImportUserDataByUserIdResult result = client.importUserDataByUserId(
new ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2Formation.Request.ImportUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithUploadToken("upload-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2Formation.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.import_user_data_by_user_id(
formation.ImportUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_upload_token('upload-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.import_user_data_by_user_id({
userId="user-0001",
uploadToken="upload-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.import_user_data_by_user_id_async({
userId="user-0001",
uploadToken="upload-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### checkImportUserDataByUserId
指定したユーザーIDに紐づくデータのインポートが完了しているか確認
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| uploadToken | string | | ✓| | ~ 1024文字 | アップロード準備で受け取ったトークン |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| url | string | 出力ログのURL |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&formation.CheckImportUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
UploadToken: pointy.String("upload-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
url := result.Url
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->checkImportUserDataByUserId(
(new CheckImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withUploadToken("upload-0001")
->withTimeOffsetToken(null)
);
$url = $result->getUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.CheckImportUserDataByUserIdRequest;
import io.gs2.formation.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
CheckImportUserDataByUserIdResult result = client.checkImportUserDataByUserId(
new CheckImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
String url = result.getUrl();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2Formation.Request.CheckImportUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithUploadToken("upload-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var url = result.Url;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2Formation.CheckImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.check_import_user_data_by_user_id(
formation.CheckImportUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_upload_token('upload-0001')
.with_time_offset_token(None)
)
url = result.url
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.check_import_user_data_by_user_id({
userId="user-0001",
uploadToken="upload-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
url = result.url;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.check_import_user_data_by_user_id_async({
userId="user-0001",
uploadToken="upload-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
url = result.url;
```
---
### describeMolds
フォームの保存領域の一覧を取得
リクエストしたユーザーのフォームの保存領域（モールド）のページネーション付きリストを取得します。
各モールドは特定のモールドモデルに対するユーザーの保存領域を表し、現在のキャパシティ情報を含みます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Mold>](#mold) | フォームの保存領域のリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.DescribeMolds(
&formation.DescribeMoldsRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\DescribeMoldsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->describeMolds(
(new DescribeMoldsRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.DescribeMoldsRequest;
import io.gs2.formation.result.DescribeMoldsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
DescribeMoldsResult result = client.describeMolds(
new DescribeMoldsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeMolds(
new Gs2.Gs2Formation.Request.DescribeMoldsRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.describeMolds(
new Gs2Formation.DescribeMoldsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.describe_molds(
formation.DescribeMoldsRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.describe_molds({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.describe_molds_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeMoldsByUserId
ユーザーIDを指定してフォームの保存領域の一覧を取得
指定されたユーザーのフォームの保存領域（モールド）のページネーション付きリストを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Mold>](#mold) | フォームの保存領域のリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.DescribeMoldsByUserId(
&formation.DescribeMoldsByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
PageToken: nil,
Limit: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\DescribeMoldsByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->describeMoldsByUserId(
(new DescribeMoldsByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withPageToken(null)
->withLimit(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.DescribeMoldsByUserIdRequest;
import io.gs2.formation.result.DescribeMoldsByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
DescribeMoldsByUserIdResult result = client.describeMoldsByUserId(
new DescribeMoldsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeMoldsByUserId(
new Gs2.Gs2Formation.Request.DescribeMoldsByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithPageToken(null)
.WithLimit(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.describeMoldsByUserId(
new Gs2Formation.DescribeMoldsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.describe_molds_by_user_id(
formation.DescribeMoldsByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_page_token(None)
.with_limit(None)
.with_time_offset_token(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.describe_molds_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
pageToken=nil,
limit=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.describe_molds_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
pageToken=nil,
limit=nil,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### getMold
フォームの保存領域を取得
保存領域モデル名を指定して、リクエストしたユーザーの特定のフォームの保存領域（モールド）を取得します。
現在のキャパシティと関連するモールドモデル情報を含むモールドを返します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| moldModelName | string | | ✓| | ~ 128文字 | フォームの保存領域モデルの名前
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Mold](#mold) | フォームの保存領域 |
| moldModel | [MoldModel](#moldmodel) | フォームの保存領域 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.GetMold(
&formation.GetMoldRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
MoldModelName: pointy.String("mold-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
moldModel := result.MoldModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\GetMoldRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->getMold(
(new GetMoldRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withMoldModelName("mold-0001")
);
$item = $result->getItem();
$moldModel = $result->getMoldModel();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.GetMoldRequest;
import io.gs2.formation.result.GetMoldResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
GetMoldResult result = client.getMold(
new GetMoldRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withMoldModelName("mold-0001")
);
Mold item = result.getItem();
MoldModel moldModel = result.getMoldModel();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetMold(
new Gs2.Gs2Formation.Request.GetMoldRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithMoldModelName("mold-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var moldModel = result.MoldModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.getMold(
new Gs2Formation.GetMoldRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withMoldModelName("mold-0001")
);
const item = result.getItem();
const moldModel = result.getMoldModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.get_mold(
formation.GetMoldRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_mold_model_name('mold-0001')
)
item = result.item
mold_model = result.mold_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.get_mold({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
moldModelName="mold-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
moldModel = result.moldModel;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.get_mold_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
moldModelName="mold-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
moldModel = result.moldModel;
```
---
### getMoldByUserId
ユーザーIDを指定してフォームの保存領域を取得
保存領域モデル名を指定して、指定されたユーザーの特定のフォームの保存領域（モールド）を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| moldModelName | string | | ✓| | ~ 128文字 | フォームの保存領域モデルの名前
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Mold](#mold) | フォームの保存領域 |
| moldModel | [MoldModel](#moldmodel) | フォームの保存領域 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.GetMoldByUserId(
&formation.GetMoldByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
MoldModelName: pointy.String("mold-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
moldModel := result.MoldModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\GetMoldByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->getMoldByUserId(
(new GetMoldByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withMoldModelName("mold-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$moldModel = $result->getMoldModel();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.GetMoldByUserIdRequest;
import io.gs2.formation.result.GetMoldByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
GetMoldByUserIdResult result = client.getMoldByUserId(
new GetMoldByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withMoldModelName("mold-0001")
.withTimeOffsetToken(null)
);
Mold item = result.getItem();
MoldModel moldModel = result.getMoldModel();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetMoldByUserId(
new Gs2.Gs2Formation.Request.GetMoldByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithMoldModelName("mold-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var moldModel = result.MoldModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.getMoldByUserId(
new Gs2Formation.GetMoldByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withMoldModelName("mold-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
const moldModel = result.getMoldModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.get_mold_by_user_id(
formation.GetMoldByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_mold_model_name('mold-0001')
.with_time_offset_token(None)
)
item = result.item
mold_model = result.mold_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.get_mold_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
moldModelName="mold-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
moldModel = result.moldModel;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.get_mold_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
moldModelName="mold-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
moldModel = result.moldModel;
```
---
### setMoldCapacityByUserId
ユーザーIDを指定してキャパシティサイズを設定
指定されたユーザーのフォームの保存領域（モールド）のキャパシティを指定の値に直接設定します。
更新前のモールドを 'old' として、更新後のモールドと共に返します。
キャパシティはモールドモデルで定義された maxCapacity で上限が制限されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| moldModelName | string | | ✓| | ~ 128文字 | フォームの保存領域モデルの名前
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| capacity | int | | ✓| | 0 ~ 2147483646 | 現在のキャパシティ
この保存領域でこのプレイヤーが現在利用できるフォーム保存スロット数です。初期値は保存領域モデルの initialMaxCapacity に設定され、キャパシティ増加操作により maxCapacity まで拡張できます。 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Mold](#mold) | キャパシティを更新したフォームの保存領域 |
| old | [Mold](#mold) | キャパシティを更新する前のフォームの保存領域 |
| moldModel | [MoldModel](#moldmodel) | フォームの保存領域 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.SetMoldCapacityByUserId(
&formation.SetMoldCapacityByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
MoldModelName: pointy.String("mold-0001"),
Capacity: pointy.Int32(10),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
old := result.Old
moldModel := result.MoldModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\SetMoldCapacityByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->setMoldCapacityByUserId(
(new SetMoldCapacityByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withMoldModelName("mold-0001")
->withCapacity(10)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$old = $result->getOld();
$moldModel = $result->getMoldModel();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.SetMoldCapacityByUserIdRequest;
import io.gs2.formation.result.SetMoldCapacityByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
SetMoldCapacityByUserIdResult result = client.setMoldCapacityByUserId(
new SetMoldCapacityByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withMoldModelName("mold-0001")
.withCapacity(10)
.withTimeOffsetToken(null)
);
Mold item = result.getItem();
Mold old = result.getOld();
MoldModel moldModel = result.getMoldModel();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.SetMoldCapacityByUserId(
new Gs2.Gs2Formation.Request.SetMoldCapacityByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithMoldModelName("mold-0001")
.WithCapacity(10)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;
var moldModel = result.MoldModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.setMoldCapacityByUserId(
new Gs2Formation.SetMoldCapacityByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withMoldModelName("mold-0001")
.withCapacity(10)
.withTimeOffsetToken(null)
);
const item = result.getItem();
const old = result.getOld();
const moldModel = result.getMoldModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.set_mold_capacity_by_user_id(
formation.SetMoldCapacityByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_mold_model_name('mold-0001')
.with_capacity(10)
.with_time_offset_token(None)
)
item = result.item
old = result.old
mold_model = result.mold_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.set_mold_capacity_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
moldModelName="mold-0001",
capacity=10,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
old = result.old;
moldModel = result.moldModel;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.set_mold_capacity_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
moldModelName="mold-0001",
capacity=10,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
old = result.old;
moldModel = result.moldModel;
```
---
### addMoldCapacityByUserId
ユーザーIDを指定してキャパシティサイズを加算
指定されたユーザーのフォームの保存領域（モールド）のキャパシティを加算します。
キャパシティはモールドモデルで定義された maxCapacity を超えることはできません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| moldModelName | string | | ✓| | ~ 128文字 | フォームの保存領域モデルの名前
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| capacity | int | | ✓| | 0 ~ 2147483646 | 現在のキャパシティ
この保存領域でこのプレイヤーが現在利用できるフォーム保存スロット数です。初期値は保存領域モデルの initialMaxCapacity に設定され、キャパシティ増加操作により maxCapacity まで拡張できます。 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Mold](#mold) | キャパシティを更新したフォームの保存領域 |
| moldModel | [MoldModel](#moldmodel) | フォームの保存領域 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.AddMoldCapacityByUserId(
&formation.AddMoldCapacityByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
MoldModelName: pointy.String("mold-0001"),
Capacity: pointy.Int32(10),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
moldModel := result.MoldModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\AddMoldCapacityByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->addMoldCapacityByUserId(
(new AddMoldCapacityByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withMoldModelName("mold-0001")
->withCapacity(10)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$moldModel = $result->getMoldModel();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.AddMoldCapacityByUserIdRequest;
import io.gs2.formation.result.AddMoldCapacityByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
AddMoldCapacityByUserIdResult result = client.addMoldCapacityByUserId(
new AddMoldCapacityByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withMoldModelName("mold-0001")
.withCapacity(10)
.withTimeOffsetToken(null)
);
Mold item = result.getItem();
MoldModel moldModel = result.getMoldModel();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.AddMoldCapacityByUserId(
new Gs2.Gs2Formation.Request.AddMoldCapacityByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithMoldModelName("mold-0001")
.WithCapacity(10)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var moldModel = result.MoldModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.addMoldCapacityByUserId(
new Gs2Formation.AddMoldCapacityByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withMoldModelName("mold-0001")
.withCapacity(10)
.withTimeOffsetToken(null)
);
const item = result.getItem();
const moldModel = result.getMoldModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.add_mold_capacity_by_user_id(
formation.AddMoldCapacityByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_mold_model_name('mold-0001')
.with_capacity(10)
.with_time_offset_token(None)
)
item = result.item
mold_model = result.mold_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.add_mold_capacity_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
moldModelName="mold-0001",
capacity=10,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
moldModel = result.moldModel;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.add_mold_capacity_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
moldModelName="mold-0001",
capacity=10,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
moldModel = result.moldModel;
```
---
### subMoldCapacity
キャパシティサイズを減算
リクエストしたユーザーのフォームの保存領域（モールド）のキャパシティを減算します。キャパシティは0を下回りません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| moldModelName | string | | ✓| | ~ 128文字 | フォームの保存領域モデルの名前
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| capacity | int | | ✓| | 0 ~ 2147483646 | 現在のキャパシティ
この保存領域でこのプレイヤーが現在利用できるフォーム保存スロット数です。初期値は保存領域モデルの initialMaxCapacity に設定され、キャパシティ増加操作により maxCapacity まで拡張できます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Mold](#mold) | キャパシティを更新したフォームの保存領域 |
| moldModel | [MoldModel](#moldmodel) | フォームの保存領域 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.SubMoldCapacity(
&formation.SubMoldCapacityRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
MoldModelName: pointy.String("mold-0001"),
Capacity: pointy.Int32(10),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
moldModel := result.MoldModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\SubMoldCapacityRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->subMoldCapacity(
(new SubMoldCapacityRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withMoldModelName("mold-0001")
->withCapacity(10)
);
$item = $result->getItem();
$moldModel = $result->getMoldModel();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.SubMoldCapacityRequest;
import io.gs2.formation.result.SubMoldCapacityResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
SubMoldCapacityResult result = client.subMoldCapacity(
new SubMoldCapacityRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withMoldModelName("mold-0001")
.withCapacity(10)
);
Mold item = result.getItem();
MoldModel moldModel = result.getMoldModel();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.SubMoldCapacity(
new Gs2.Gs2Formation.Request.SubMoldCapacityRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithMoldModelName("mold-0001")
.WithCapacity(10),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var moldModel = result.MoldModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.subMoldCapacity(
new Gs2Formation.SubMoldCapacityRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withMoldModelName("mold-0001")
.withCapacity(10)
);
const item = result.getItem();
const moldModel = result.getMoldModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.sub_mold_capacity(
formation.SubMoldCapacityRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_mold_model_name('mold-0001')
.with_capacity(10)
)
item = result.item
mold_model = result.mold_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.sub_mold_capacity({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
moldModelName="mold-0001",
capacity=10,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
moldModel = result.moldModel;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.sub_mold_capacity_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
moldModelName="mold-0001",
capacity=10,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
moldModel = result.moldModel;
```
---
### subMoldCapacityByUserId
ユーザーIDを指定してキャパシティサイズを減算
指定されたユーザーのフォームの保存領域（モールド）のキャパシティを減算します。キャパシティは0を下回りません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| moldModelName | string | | ✓| | ~ 128文字 | フォームの保存領域モデルの名前
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| capacity | int | | ✓| | 0 ~ 2147483646 | 現在のキャパシティ
この保存領域でこのプレイヤーが現在利用できるフォーム保存スロット数です。初期値は保存領域モデルの initialMaxCapacity に設定され、キャパシティ増加操作により maxCapacity まで拡張できます。 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Mold](#mold) | キャパシティを更新したフォームの保存領域 |
| moldModel | [MoldModel](#moldmodel) | フォームの保存領域 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.SubMoldCapacityByUserId(
&formation.SubMoldCapacityByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
MoldModelName: pointy.String("mold-0001"),
Capacity: pointy.Int32(10),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
moldModel := result.MoldModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\SubMoldCapacityByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->subMoldCapacityByUserId(
(new SubMoldCapacityByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withMoldModelName("mold-0001")
->withCapacity(10)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$moldModel = $result->getMoldModel();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.SubMoldCapacityByUserIdRequest;
import io.gs2.formation.result.SubMoldCapacityByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
SubMoldCapacityByUserIdResult result = client.subMoldCapacityByUserId(
new SubMoldCapacityByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withMoldModelName("mold-0001")
.withCapacity(10)
.withTimeOffsetToken(null)
);
Mold item = result.getItem();
MoldModel moldModel = result.getMoldModel();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.SubMoldCapacityByUserId(
new Gs2.Gs2Formation.Request.SubMoldCapacityByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithMoldModelName("mold-0001")
.WithCapacity(10)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var moldModel = result.MoldModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.subMoldCapacityByUserId(
new Gs2Formation.SubMoldCapacityByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withMoldModelName("mold-0001")
.withCapacity(10)
.withTimeOffsetToken(null)
);
const item = result.getItem();
const moldModel = result.getMoldModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.sub_mold_capacity_by_user_id(
formation.SubMoldCapacityByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_mold_model_name('mold-0001')
.with_capacity(10)
.with_time_offset_token(None)
)
item = result.item
mold_model = result.mold_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.sub_mold_capacity_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
moldModelName="mold-0001",
capacity=10,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
moldModel = result.moldModel;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.sub_mold_capacity_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
moldModelName="mold-0001",
capacity=10,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
moldModel = result.moldModel;
```
---
### deleteMold
フォームの保存領域を削除
リクエストしたユーザーのフォームの保存領域（モールド）を削除します。保存領域内のすべてのフォームとキャパシティデータが削除されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| moldModelName | string | | ✓| | ~ 128文字 | フォームの保存領域モデルの名前
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Mold](#mold) | フォームの保存領域 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.DeleteMold(
&formation.DeleteMoldRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
MoldModelName: pointy.String("mold-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\DeleteMoldRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->deleteMold(
(new DeleteMoldRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withMoldModelName("mold-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.DeleteMoldRequest;
import io.gs2.formation.result.DeleteMoldResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
DeleteMoldResult result = client.deleteMold(
new DeleteMoldRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withMoldModelName("mold-0001")
);
Mold item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteMold(
new Gs2.Gs2Formation.Request.DeleteMoldRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithMoldModelName("mold-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.deleteMold(
new Gs2Formation.DeleteMoldRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withMoldModelName("mold-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.delete_mold(
formation.DeleteMoldRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_mold_model_name('mold-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.delete_mold({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
moldModelName="mold-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.delete_mold_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
moldModelName="mold-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteMoldByUserId
ユーザーIDを指定してフォームの保存領域を削除
指定されたユーザーのフォームの保存領域（モールド）を削除します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| moldModelName | string | | ✓| | ~ 128文字 | フォームの保存領域モデルの名前
フォームの保存領域モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Mold](#mold) | フォームの保存領域 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.DeleteMoldByUserId(
&formation.DeleteMoldByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
MoldModelName: pointy.String("mold-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\DeleteMoldByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->deleteMoldByUserId(
(new DeleteMoldByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withMoldModelName("mold-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.DeleteMoldByUserIdRequest;
import io.gs2.formation.result.DeleteMoldByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
DeleteMoldByUserIdResult result = client.deleteMoldByUserId(
new DeleteMoldByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withMoldModelName("mold-0001")
.withTimeOffsetToken(null)
);
Mold item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2FormationRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteMoldByUserId(
new Gs2.Gs2Formation.Request.DeleteMoldByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithMoldModelName("mold-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Formation from '@/gs2/formation';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Formation.Gs2FormationRestClient(session);
try {
const result = await client.deleteMoldByUserId(
new Gs2Formation.DeleteMoldByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withMoldModelName("mold-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import formation
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = formation.Gs2FormationRestClient(session)
try:
result = client.delete_mold_by_user_id(
formation.DeleteMoldByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_mold_model_name('mold-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('formation')
api_result = client.delete_mold_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
moldModelName="mold-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('formation')
api_result_handler = client.delete_mold_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
moldModelName="mold-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeForms
フォームの一覧を取得
指定されたモールド（フォームの保存領域）内の、リクエストしたユーザーのフォームのページネーション付きリストを取得します。
各フォームには、インベントリ、シンプルインベントリ、辞書のアイテムへの参照を保持できるスロットのセットが含まれます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| moldModelName | string | | ✓| | ~ 128文字 | フォームの保存領域モデルの名前 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Form>](#form) | フォームのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/formation"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := formation.Gs2FormationRestClient{
Session: &session,
}
result, err := client.DescribeForms(
&formation.DescribeFormsRequest {
NamespaceName: pointy.String("namespace-0001"),
MoldModelName: pointy.String("mold-0001"),
AccessToken: pointy.String("accessToken-0001"),
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Formation\Gs2FormationRestClient;
use Gs2\Formation\Request\DescribeFormsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2FormationRestClient(
$session
);
try {
$result = $client->describeForms(
(new DescribeFormsRequest())
->withNamespaceName("namespace-0001")
->withMoldModelName("mold-0001")
->withAccessToken("accessToken-0001")
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.formation.rest.Gs2FormationRestClient;
import io.gs2.formation.request.DescribeFormsRequest;
import io.gs2.formation.result.DescribeFormsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2FormationRestClient client = new Gs2FormationRestClient(session);
try {
DescribeFormsResult result = client.describeForms(
new DescribeFormsRequest()
.withNamespaceName("namespace-0001")
.withMoldModelName("mold-0001")
.withAccessToken("accessToken-0001")
.withPageToken(null)
.withLimit(null)
);
List