> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-StateMachine SDK API リファレンス
各種プログラミング言語向け GS2-StateMachine SDK の モデルの仕様 と API のリファレンス
## モデル
### Namespace
ネームスペース
ネームスペースは、一つのプロジェクト内で同じサービスを異なる用途で複数利用するためのエンティティです。
GS2 の各サービスはネームスペース単位で管理されます。ネームスペースが異なれば、同じサービスでも完全に独立したデータ空間として扱われます。
そのため、各サービスの利用を開始するにあたってネームスペースを作成する必要があります。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024文字 | ネームスペースGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| supportSpeculativeExecution | 文字列列挙型
enum {
"enable",
"disable"
}
| | | "disable" | | 投機的実行をサポートするか
有効にすると、ステートマシン定義と乱数状態が Status エンティティに埋め込まれ、クライアントがサーバー確認前にローカルで状態遷移をシミュレーションできるようになります。transactionSetting の設定が必要です。"enable": 有効 / "disable": 無効 / |
| transactionSetting | [TransactionSetting](#transactionsetting) | {supportSpeculativeExecution} == "enable" | | | | トランザクション設定
ステートマシンの emit アクション実行時のトランザクションの処理方法を制御する設定です。投機的実行を有効にする場合に必要です。
※ supportSpeculativeExecution が "enable" であれば 有効 |
| startScript | [ScriptSetting](#scriptsetting) | | | | | ステートマシンを起動したときに実行するスクリプトの設定
Script トリガーリファレンス - [`start`](../script/#start) |
| passScript | [ScriptSetting](#scriptsetting) | | | | | ステートマシンが正常終了したときに実行するスクリプトの設定
Script トリガーリファレンス - [`pass`](../script/#pass) |
| errorScript | [ScriptSetting](#scriptsetting) | | | | | ステートマシンが異常終了したときに実行するスクリプトの設定
Script トリガーリファレンス - [`error`](../script/#error) |
| lowestStateMachineVersion | long | | | | | ステートマシンの最低バージョン
実行可能なステートマシンの最低バージョンです。この値より古いバージョンのステートマシンで作成された Status インスタンスは拒否され、すべての実行中インスタンスが最新の定義を使用することが保証されます。 |
| logSetting | [LogSetting](#logsetting) | | | | | ログの出力設定
ステートマシンの実行、状態遷移、emit イベントに関する API リクエスト・レスポンスログを出力する GS2-Log のネームスペースを指定します。 |
| 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文字 | 完了時に実行するスクリプトGRN
「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。
※ doneTriggerTargetType が "gs2_script" であれば 有効 |
| doneTriggerQueueNamespaceId | string | {doneTriggerTargetType} == "gs2_script" | | | ~ 1024文字 | 完了時のスクリプトを実行する GS2-JobQueue ネームスペースGRN
完了スクリプトの完了を知りたい時に使用します。
※ 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 - ネームスペース
---
### Status
ステートマシンの状態
特定のユーザーに対するステートマシンの実行インスタンスを表します。変数、サブステートマシン用のコールスタック、遷移回数、乱数状態を含む現在の実行状態を追跡します。ステータスは Running、Wait、Pass（成功）、Error の状態を遷移します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| statusId | string | | ※ | | ~ 1024文字 | ステートマシンの状態GRN
※ サーバーが自動で設定 |
| userId | string | | ✓ | | ~ 128文字 | ユーザーID |
| name | string | | ✓ | UUID | ~ 36文字 | ステータス名
ステートマシンの状態の一意な名前を保持します。
名前は UUID（Universally Unique Identifier）フォーマットで自動的に生成され、各ステートマシンの状態を識別するために使用されます。 |
| stateMachineVersion | long | | ✓ | | 0 ~ 32503680000000 | バージョン
このステートマシン定義のバージョン識別子です。作成時に自動的に割り当てられます。ネームスペースの lowestStateMachineVersion と組み合わせて、実行中インスタンスのバージョン互換性を強制するために使用されます。 |
| enableSpeculativeExecution | 文字列列挙型
enum {
"enable",
"disable"
}
| | | "disable" | | 投機的実行を有効にするか
有効にすると、ステートマシン定義と乱数状態がこの Status エンティティに含まれます。これによりクライアントがサーバー確認前にローカルで遷移をシミュレーションでき、体感遅延を軽減できます。"enable": 有効 / "disable": 無効 / |
| stateMachineDefinition | string | {enableSpeculativeExecution} == "enable" | | | ~ 16777216文字 | ステートマシン定義
投機的実行のためにこのステータスに埋め込まれた GSL 定義です。enableSpeculativeExecution が有効な場合のみ存在します。通常の API レスポンスではフィルタリングされ、クライアント側シミュレーションに必要な場合のみ含まれます。
※ enableSpeculativeExecution が "enable" であれば 有効 |
| randomStatus | [RandomStatus](#randomstatus) | {enableSpeculativeExecution} == "enable" | | | | 乱数状態
この実行インスタンスの乱数生成状態です。投機的実行時にクライアントとサーバーで決定論的な乱数動作を保証するために使用されます。enableSpeculativeExecution が有効な場合のみ存在します。
※ enableSpeculativeExecution が "enable" であれば 有効 |
| stacks | [List<StackEntry>](#stackentry) | | | [] | 0 ~ 1024 items | スタック
サブステートマシン呼び出しのコールスタックです。ステートマシンがサブステートマシンを呼び出すと、呼び出し元のステートマシン名と戻り先タスクがプッシュされます。サブステートマシンが完了するとエントリがポップされ、戻り先タスクから実行が再開されます。 |
| variables | [List<Variable>](#variable) | | | [] | 0 ~ 1000 items | ステートマシンごとの状態変数
コール階層内の各ステートマシンの現在の変数値です。各エントリはステートマシン名と、int、float、string、bool、array、map 型をサポートする JSON シリアライズされた値を保持します。変数は同一実行インスタンス内の状態遷移を通じて永続化されます。 |
| status | 文字列列挙型
enum {
"Running",
"Wait",
"Pass",
"Error"
}
| | | "Running" | | ステータス
このステートマシンインスタンスの現在の実行状態です。「Running」はマシンが遷移を処理中であることを意味します。「Wait」はマシンが外部イベント（emit）を待機中であることを意味します。「Pass」は正常に完了したことを意味します。「Error」はエラーで終了したことを意味します。"Running": 実行中 / "Wait": 待機中 / "Pass": 正常終了 / "Error": 異常終了 / |
| lastError | string | | | | ~ 1024文字 | 最後のエラー
最後に発生したエラーのメッセージです。ステータスが「Error」に遷移した際に設定されます。ステートマシンが異常終了した原因の詳細を含みます。 |
| transitionCount | int | | | 0 | 0 ~ 2147483645 | 遷移回数
この実行インスタンスで実行された状態遷移の合計回数です。遷移ごとに加算されます。この値が1000を超えると、無限ループを防ぐためステートマシンはエラーで終了します。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
**関連するメソッド:**
describeStatuses - ステートマシンの状態のリストを取得
describeStatusesByUserId - ユーザーIDを指定してステートマシンの状態のリストを取得
getStatus - ステートマシンの状態を取得
getStatusByUserId - ユーザーIDを指定してステートマシンの状態を取得
startStateMachineByUserId - ユーザーIDを指定してステートマシンを開始
emit - ステートマシンにイベントを送信
emitByUserId - ユーザーIDを指定してステートマシンにイベントを送信
report - ステートマシンに複数のイベントを報告
reportByUserId - ユーザーIDを指定してステートマシンに複数のイベントを報告
deleteStatusByUserId - ユーザーIDを指定してステートマシンの状態を削除
exitStateMachine - ステートマシンを終了して削除
exitStateMachineByUserId - ユーザーIDを指定してステートマシンを終了して削除
---
### StackEntry
スタックエントリ
サブステートマシンのコールスタック内の1つのエントリを表します。ステートマシンがサブステートマシンを呼び出すと、呼び出し元の名前と戻り先タスクがスタックにプッシュされます。サブステートマシンが完了すると、ポップされたエントリの戻り先タスクから実行が再開されます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| stateMachineName | string | | ✓ | | ~ 128文字 | ステートマシン名
このスタックエントリをプッシュした呼び出し元ステートマシンの名前です。サブステートマシンから戻る際に、どのステートマシンのコンテキストを復元するかの識別に使用されます。 |
| taskName | string | | ✓ | | ~ 128文字 | タスク名
サブステートマシンが完了した際に戻るタスク（状態）の名前です。呼び出し元ステートマシンのこのタスクから実行が再開されます。 |
**関連するモデル:**
Status - ステートマシンの状態
---
### Variable
ステートマシンごとの状態変数
コール階層内の特定のステートマシンの現在の変数状態を保持します。値は int、float、string、bool、array、map データ型をサポートする JSON シリアライズされた表現です。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| stateMachineName | string | | ✓ | | ~ 128文字 | ステートマシン名
これらの変数を所有するステートマシンの名前です。ネストされたコール階層では、各ステートマシンがこの名前で識別される独立した変数スコープを持ちます。 |
| value | string | | ✓ | | ~ 1048576文字 | 値
このステートマシンの JSON シリアライズされた変数値です。int、float、string、bool、array、map データ型をサポートします。ステートマシンが遷移やアクションを処理する際に更新されます。 |
**関連するモデル:**
Status - ステートマシンの状態
---
### Event
イベント
ステートマシン実行中に発生したイベントを表します。ステート変更イベント（状態遷移の記録）または emit イベント（外部アクションをトリガーするメッセージの送信）のいずれかです。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| eventType | 文字列列挙型
enum {
"change_state",
"emit"
}
| | ✓ | | | イベントの種類
イベントの種類です。「change_state」はステートマシン内の状態遷移を記録します。「emit」は報酬の付与やリソースの消費などの外部アクションをトリガーするメッセージの送信を表します。"change_state": ステートの変更 / "emit": メッセージの送信 / |
| changeStateEvent | [ChangeStateEvent](#changestateevent) | {eventType} == "change_state" | ✓※ | | | ステートの変更
※ eventType が "change_state" であれば 必須 |
| emitEvent | [EmitEvent](#emitevent) | {eventType} == "emit" | ✓※ | | | メッセージの送信
※ eventType が "emit" であれば 必須 |
---
### ChangeStateEvent
ステートの変更イベント
ステートマシン内で発生した状態遷移を記録します。遷移先のタスク名、整合性検証用のハッシュ、および遷移のタイムスタンプを含みます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| taskName | string | | ✓ | | ~ 128文字 | タスク名
ステートマシンが遷移した先のタスク（状態）の名前です。 |
| hash | string | | ✓ | | ~ 64文字 | ハッシュ
状態遷移の整合性を検証するためのハッシュ値です。遷移が正しく実行され、状態が一貫していることを検証するために使用されます。 |
| timestamp | long | | ✓ | | | タイムスタンプ |
**関連するモデル:**
Event - イベント
---
### EmitEvent
メッセージの送信イベント
外部アクションをトリガーするためにステートマシンが送信するメッセージを表します。イベント名はアクションの種類を識別し、パラメータはアクション固有のデータを提供します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| event | string | | ✓ | | ~ 128文字 | イベント名
送信されたイベントの種類を識別する名前です。報酬の付与やリソースの消費など、どの外部アクションを呼び出すかの判定に使用されます。 |
| parameters | string | | ✓ | | ~ 1024文字 | パラメータ
送信されたイベントに渡されるパラメータです。このイベントによってトリガーされる外部アクションを設定するために使用される、アクション固有のデータをシリアライズ形式で含みます。 |
| timestamp | long | | ✓ | | | タイムスタンプ |
**関連するモデル:**
Event - イベント
---
### RandomStatus
乱数の状態
ステートマシン実行インスタンスの乱数生成状態を管理します。シード値とカテゴリごとの使用状況追跡を含みます。投機的実行時にクライアントとサーバーで決定論的な乱数動作を保証するために使用されます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| seed | long | | ✓ | | 0 ~ 4294967294 | 乱数シード
ステートマシン実行内での決定論的な乱数生成のためのシード値です。 |
| used | [List<RandomUsed>](#randomused) | | | | 0 ~ 1000 items | 使用済み乱数リスト
カテゴリごとに消費された乱数を追跡します。各カテゴリは乱数使用の異なる目的を表し、投機的再実行時の一貫性を維持するための独立した追跡を可能にします。 |
**関連するモデル:**
Status - ステートマシンの状態
---
### RandomUsed
使用済み乱数
ステートマシン実行内の特定カテゴリで消費された乱数の数を追跡します。各カテゴリは異なる目的での独立した乱数追跡を可能にします。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| category | long | | ✓ | | 0 ~ 4294967294 | カテゴリ
乱数使用カテゴリの数値識別子です。各カテゴリは乱数消費を独立して追跡し、ステートマシンが異なる目的に別々の乱数シーケンスを使用できるようにします。 |
| used | long | | ✓ | | 0 ~ 4294967294 | 使用回数
このカテゴリで消費された乱数の数です。このカテゴリのシーケンスから乱数が引かれるたびに増加します。 |
**関連するモデル:**
RandomStatus - 乱数の状態
---
### 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 | | トランザクション実行中にエラーが発生したかどうか |
---
### StateMachineMaster
ステートマシン定義
GSLで記述されたステートマシンを管理します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| stateMachineId | string | | ※ | | ~ 1024文字 | ステートマシンマスターGRN
※ サーバーが自動で設定 |
| mainStateMachineName | string | | ✓ | | ~ 128文字 | メインステートマシン名
GSL 定義内のエントリポイントとなるステートマシンの名前です。このステートマシンから実行が開始され、スタック機構を通じてサブステートマシンを呼び出すことができます。 |
| payload | string | | ✓ | | ~ 5242880文字 | ステートマシン定義
ステートマシンの状態、遷移、アクションを定義する GSL（GS2 State Language）のソースコードです。効率的な取得のためにメタデータとは別に保存されます。 |
| version | long | | ✓ | | 0 ~ 32503680000000 | バージョン
このステートマシン定義のバージョン識別子です。作成時に自動的に割り当てられます。ネームスペースの lowestStateMachineVersion と組み合わせて、実行中インスタンスのバージョン互換性を強制するために使用されます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeStateMachineMasters - ステートマシンマスターの一覧を取得
updateStateMachineMaster - ステートマシンマスターを作成または更新
getStateMachineMaster - ステートマシンマスターを取得
deleteStateMachineMaster - ステートマシンマスターを削除
---
## メソッド
### 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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.DescribeNamespacesRequest;
import io.gs2.stateMachine.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2StateMachine.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 state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.describe_namespaces(
state_machine.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('state_machine')
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('state_machine')
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文字 | 説明文 |
| supportSpeculativeExecution | 文字列列挙型
enum {
"enable",
"disable"
}
| | | "disable" | | 投機的実行をサポートするか
有効にすると、ステートマシン定義と乱数状態が Status エンティティに埋め込まれ、クライアントがサーバー確認前にローカルで状態遷移をシミュレーションできるようになります。transactionSetting の設定が必要です。"enable": 有効 / "disable": 無効 / |
| transactionSetting | [TransactionSetting](#transactionsetting) | {supportSpeculativeExecution} == "enable" | | | | トランザクション設定
ステートマシンの emit アクション実行時のトランザクションの処理方法を制御する設定です。投機的実行を有効にする場合に必要です。
※ supportSpeculativeExecution が "enable" であれば有効 |
| startScript | [ScriptSetting](#scriptsetting) | | | | | ステートマシンを起動したときに実行するスクリプトの設定
Script トリガーリファレンス - [`start`](../script/#start) |
| passScript | [ScriptSetting](#scriptsetting) | | | | | ステートマシンが正常終了したときに実行するスクリプトの設定
Script トリガーリファレンス - [`pass`](../script/#pass) |
| errorScript | [ScriptSetting](#scriptsetting) | | | | | ステートマシンが異常終了したときに実行するスクリプトの設定
Script トリガーリファレンス - [`error`](../script/#error) |
| lowestStateMachineVersion | long | | | | | ステートマシンの最低バージョン
実行可能なステートマシンの最低バージョンです。この値より古いバージョンのステートマシンで作成された Status インスタンスは拒否され、すべての実行中インスタンスが最新の定義を使用することが保証されます。 |
| logSetting | [LogSetting](#logsetting) | | | | | ログの出力設定
ステートマシンの実行、状態遷移、emit イベントに関する API リクエスト・レスポンスログを出力する GS2-Log のネームスペースを指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 作成したネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&state_machine.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
SupportSpeculativeExecution: nil,
TransactionSetting: nil,
StartScript: nil,
PassScript: nil,
ErrorScript: nil,
LowestStateMachineVersion: nil,
LogSetting: &stateMachine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withSupportSpeculativeExecution(null)
->withTransactionSetting(null)
->withStartScript(null)
->withPassScript(null)
->withErrorScript(null)
->withLowestStateMachineVersion(null)
->withLogSetting((new \Gs2\StateMachine\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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.CreateNamespaceRequest;
import io.gs2.stateMachine.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withSupportSpeculativeExecution(null)
.withTransactionSetting(null)
.withStartScript(null)
.withPassScript(null)
.withErrorScript(null)
.withLowestStateMachineVersion(null)
.withLogSetting(new io.gs2.stateMachine.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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2StateMachine.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithSupportSpeculativeExecution(null)
.WithTransactionSetting(null)
.WithStartScript(null)
.WithPassScript(null)
.WithErrorScript(null)
.WithLowestStateMachineVersion(null)
.WithLogSetting(new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.createNamespace(
new Gs2StateMachine.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withSupportSpeculativeExecution(null)
.withTransactionSetting(null)
.withStartScript(null)
.withPassScript(null)
.withErrorScript(null)
.withLowestStateMachineVersion(null)
.withLogSetting(new Gs2StateMachine.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 state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.create_namespace(
state_machine.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_support_speculative_execution(None)
.with_transaction_setting(None)
.with_start_script(None)
.with_pass_script(None)
.with_error_script(None)
.with_lowest_state_machine_version(None)
.with_log_setting(
state_machine.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('state_machine')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
supportSpeculativeExecution=nil,
transactionSetting=nil,
startScript=nil,
passScript=nil,
errorScript=nil,
lowestStateMachineVersion=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('state_machine')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
supportSpeculativeExecution=nil,
transactionSetting=nil,
startScript=nil,
passScript=nil,
errorScript=nil,
lowestStateMachineVersion=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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.GetNamespaceStatusRequest;
import io.gs2.stateMachine.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2StateMachine.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.get_namespace_status(
state_machine.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
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('state_machine')
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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.GetNamespaceRequest;
import io.gs2.stateMachine.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.getNamespace(
new Gs2StateMachine.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.get_namespace(
state_machine.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
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('state_machine')
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文字 | 説明文 |
| supportSpeculativeExecution | 文字列列挙型
enum {
"enable",
"disable"
}
| | | "disable" | | 投機的実行をサポートするか
有効にすると、ステートマシン定義と乱数状態が Status エンティティに埋め込まれ、クライアントがサーバー確認前にローカルで状態遷移をシミュレーションできるようになります。transactionSetting の設定が必要です。"enable": 有効 / "disable": 無効 / |
| transactionSetting | [TransactionSetting](#transactionsetting) | {supportSpeculativeExecution} == "enable" | | | | トランザクション設定
ステートマシンの emit アクション実行時のトランザクションの処理方法を制御する設定です。投機的実行を有効にする場合に必要です。
※ supportSpeculativeExecution が "enable" であれば有効 |
| startScript | [ScriptSetting](#scriptsetting) | | | | | ステートマシンを起動したときに実行するスクリプトの設定
Script トリガーリファレンス - [`start`](../script/#start) |
| passScript | [ScriptSetting](#scriptsetting) | | | | | ステートマシンが正常終了したときに実行するスクリプトの設定
Script トリガーリファレンス - [`pass`](../script/#pass) |
| errorScript | [ScriptSetting](#scriptsetting) | | | | | ステートマシンが異常終了したときに実行するスクリプトの設定
Script トリガーリファレンス - [`error`](../script/#error) |
| lowestStateMachineVersion | long | | | | | ステートマシンの最低バージョン
実行可能なステートマシンの最低バージョンです。この値より古いバージョンのステートマシンで作成された Status インスタンスは拒否され、すべての実行中インスタンスが最新の定義を使用することが保証されます。 |
| logSetting | [LogSetting](#logsetting) | | | | | ログの出力設定
ステートマシンの実行、状態遷移、emit イベントに関する API リクエスト・レスポンスログを出力する GS2-Log のネームスペースを指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 更新したネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&state_machine.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
SupportSpeculativeExecution: nil,
TransactionSetting: nil,
StartScript: nil,
PassScript: nil,
ErrorScript: nil,
LowestStateMachineVersion: nil,
LogSetting: &stateMachine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withSupportSpeculativeExecution(null)
->withTransactionSetting(null)
->withStartScript(null)
->withPassScript(null)
->withErrorScript(null)
->withLowestStateMachineVersion(null)
->withLogSetting((new \Gs2\StateMachine\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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.UpdateNamespaceRequest;
import io.gs2.stateMachine.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withSupportSpeculativeExecution(null)
.withTransactionSetting(null)
.withStartScript(null)
.withPassScript(null)
.withErrorScript(null)
.withLowestStateMachineVersion(null)
.withLogSetting(new io.gs2.stateMachine.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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2StateMachine.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithSupportSpeculativeExecution(null)
.WithTransactionSetting(null)
.WithStartScript(null)
.WithPassScript(null)
.WithErrorScript(null)
.WithLowestStateMachineVersion(null)
.WithLogSetting(new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2StateMachine.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withSupportSpeculativeExecution(null)
.withTransactionSetting(null)
.withStartScript(null)
.withPassScript(null)
.withErrorScript(null)
.withLowestStateMachineVersion(null)
.withLogSetting(new Gs2StateMachine.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 state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.update_namespace(
state_machine.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_support_speculative_execution(None)
.with_transaction_setting(None)
.with_start_script(None)
.with_pass_script(None)
.with_error_script(None)
.with_lowest_state_machine_version(None)
.with_log_setting(
state_machine.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('state_machine')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
supportSpeculativeExecution=nil,
transactionSetting=nil,
startScript=nil,
passScript=nil,
errorScript=nil,
lowestStateMachineVersion=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('state_machine')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
supportSpeculativeExecution=nil,
transactionSetting=nil,
startScript=nil,
passScript=nil,
errorScript=nil,
lowestStateMachineVersion=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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.DeleteNamespaceRequest;
import io.gs2.stateMachine.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2StateMachine.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.delete_namespace(
state_machine.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
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('state_machine')
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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.GetServiceVersionRequest;
import io.gs2.stateMachine.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2StateMachine.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.get_service_version(
state_machine.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
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('state_machine')
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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.DumpUserDataByUserIdRequest;
import io.gs2.stateMachine.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2StateMachine.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.dump_user_data_by_user_id(
state_machine.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
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('state_machine')
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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.stateMachine.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2StateMachine.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
state_machine.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('state_machine')
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('state_machine')
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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.CleanUserDataByUserIdRequest;
import io.gs2.stateMachine.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2StateMachine.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.clean_user_data_by_user_id(
state_machine.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
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('state_machine')
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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.stateMachine.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2StateMachine.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
state_machine.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
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('state_machine')
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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.stateMachine.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2StateMachine.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 state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
state_machine.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('state_machine')
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('state_machine')
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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.ImportUserDataByUserIdRequest;
import io.gs2.stateMachine.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2StateMachine.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.import_user_data_by_user_id(
state_machine.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('state_machine')
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('state_machine')
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/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&state_machine.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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.CheckImportUserDataByUserIdRequest;
import io.gs2.stateMachine.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2StateMachine.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2StateMachine.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 state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.check_import_user_data_by_user_id(
state_machine.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('state_machine')
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('state_machine')
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;
```
---
### describeStatuses
ステートマシンの状態のリストを取得
リクエストしたユーザーのステートマシン状態のページネーション付きリストを取得します。ステータス（Running、Pass、Error）でフィルタリングして、特定の状態のステートマシンのみを取得できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| status | 文字列列挙型
enum {
"Running",
"Wait",
"Pass",
"Error"
}
| | | | | ステータス
このステートマシンインスタンスの現在の実行状態です。「Running」はマシンが遷移を処理中であることを意味します。「Wait」はマシンが外部イベント（emit）を待機中であることを意味します。「Pass」は正常に完了したことを意味します。「Error」はエラーで終了したことを意味します。"Running": 実行中 / "Wait": 待機中 / "Pass": 正常終了 / "Error": 異常終了 / |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Status>](#status) | ステートマシンの状態のリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.DescribeStatuses(
&state_machine.DescribeStatusesRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
Status: pointy.String("Running"),
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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\DescribeStatusesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->describeStatuses(
(new DescribeStatusesRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withStatus("Running")
->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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.DescribeStatusesRequest;
import io.gs2.stateMachine.result.DescribeStatusesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
DescribeStatusesResult result = client.describeStatuses(
new DescribeStatusesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withStatus("Running")
.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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeStatuses(
new Gs2.Gs2StateMachine.Request.DescribeStatusesRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithStatus("Running")
.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.describeStatuses(
new Gs2StateMachine.DescribeStatusesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withStatus("Running")
.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 state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.describe_statuses(
state_machine.DescribeStatusesRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_status('Running')
.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('state_machine')
api_result = client.describe_statuses({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
status="Running",
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('state_machine')
api_result_handler = client.describe_statuses_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
status="Running",
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;
```
---
### describeStatusesByUserId
ユーザーIDを指定してステートマシンの状態のリストを取得
指定したユーザーのステートマシン状態のページネーション付きリストを取得します。ステータス（Running、Pass、Error）でフィルタリングして、特定の状態のステートマシンのみを取得できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| status | 文字列列挙型
enum {
"Running",
"Wait",
"Pass",
"Error"
}
| | | | | ステータス
このステートマシンインスタンスの現在の実行状態です。「Running」はマシンが遷移を処理中であることを意味します。「Wait」はマシンが外部イベント（emit）を待機中であることを意味します。「Pass」は正常に完了したことを意味します。「Error」はエラーで終了したことを意味します。"Running": 実行中 / "Wait": 待機中 / "Pass": 正常終了 / "Error": 異常終了 / |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Status>](#status) | ステートマシンの状態のリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.DescribeStatusesByUserId(
&state_machine.DescribeStatusesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
Status: nil,
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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\DescribeStatusesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->describeStatusesByUserId(
(new DescribeStatusesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withStatus(null)
->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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.DescribeStatusesByUserIdRequest;
import io.gs2.stateMachine.result.DescribeStatusesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
DescribeStatusesByUserIdResult result = client.describeStatusesByUserId(
new DescribeStatusesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatus(null)
.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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeStatusesByUserId(
new Gs2.Gs2StateMachine.Request.DescribeStatusesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithStatus(null)
.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.describeStatusesByUserId(
new Gs2StateMachine.DescribeStatusesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatus(null)
.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 state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.describe_statuses_by_user_id(
state_machine.DescribeStatusesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_status(None)
.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('state_machine')
api_result = client.describe_statuses_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
status=nil,
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('state_machine')
api_result_handler = client.describe_statuses_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
status=nil,
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;
```
---
### getStatus
ステートマシンの状態を取得
現在の状態、変数、スタックトレース、エラー情報を含む、リクエストしたユーザーのステートマシン状態を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| statusName | string | | ✓| | ~ 36文字 | ステータス名 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | ステートマシンの状態 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.GetStatus(
&state_machine.GetStatusRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
StatusName: pointy.String("status-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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\GetStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->getStatus(
(new GetStatusRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withStatusName("status-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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.GetStatusRequest;
import io.gs2.stateMachine.result.GetStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
GetStatusResult result = client.getStatus(
new GetStatusRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withStatusName("status-0001")
);
Status 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetStatus(
new Gs2.Gs2StateMachine.Request.GetStatusRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithStatusName("status-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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.getStatus(
new Gs2StateMachine.GetStatusRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withStatusName("status-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.get_status(
state_machine.GetStatusRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_status_name('status-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.get_status({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
statusName="status-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('state_machine')
api_result_handler = client.get_status_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
statusName="status-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;
```
---
### getStatusByUserId
ユーザーIDを指定してステートマシンの状態を取得
現在の状態、変数、スタックトレース、エラー情報を含む、指定したユーザーのステートマシン状態を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| statusName | string | | ✓| | ~ 36文字 | ステータス名 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | ステートマシンの状態 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.GetStatusByUserId(
&state_machine.GetStatusByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
StatusName: pointy.String("status-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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\GetStatusByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->getStatusByUserId(
(new GetStatusByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withStatusName("status-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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.GetStatusByUserIdRequest;
import io.gs2.stateMachine.result.GetStatusByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
GetStatusByUserIdResult result = client.getStatusByUserId(
new GetStatusByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatusName("status-0001")
.withTimeOffsetToken(null)
);
Status 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetStatusByUserId(
new Gs2.Gs2StateMachine.Request.GetStatusByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithStatusName("status-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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.getStatusByUserId(
new Gs2StateMachine.GetStatusByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatusName("status-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.get_status_by_user_id(
state_machine.GetStatusByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_status_name('status-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.get_status_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
statusName="status-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('state_machine')
api_result_handler = client.get_status_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
statusName="status-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;
```
---
### startStateMachineByUserId
ユーザーIDを指定してステートマシンを開始
最新のマスターバージョンを使用して、指定したユーザーの新しいステートマシンインスタンスを開始します。引数はJSONとして渡され、ステートマシン変数にパースされます。オプションのTTL（分単位）を設定できます。省略した場合、ステートマシンは約10年間有効です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| args | string | | | "{}" | ~ 4096文字 | ステートマシンに渡す引数 |
| ttl | int | | | | 1 ~ 525600 | 有効期間(分) |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 開始したステートマシンの状態 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.StartStateMachineByUserId(
&state_machine.StartStateMachineByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
Args: nil,
Ttl: nil,
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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\StartStateMachineByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->startStateMachineByUserId(
(new StartStateMachineByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withArgs(null)
->withTtl(null)
->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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.StartStateMachineByUserIdRequest;
import io.gs2.stateMachine.result.StartStateMachineByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
StartStateMachineByUserIdResult result = client.startStateMachineByUserId(
new StartStateMachineByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withArgs(null)
.withTtl(null)
.withTimeOffsetToken(null)
);
Status 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.StartStateMachineByUserId(
new Gs2.Gs2StateMachine.Request.StartStateMachineByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithArgs(null)
.WithTtl(null)
.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.startStateMachineByUserId(
new Gs2StateMachine.StartStateMachineByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withArgs(null)
.withTtl(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.start_state_machine_by_user_id(
state_machine.StartStateMachineByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_args(None)
.with_ttl(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.start_state_machine_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
args=nil,
ttl=nil,
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('state_machine')
api_result_handler = client.start_state_machine_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
args=nil,
ttl=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
item = result.item;
```
---
### emit
ステートマシンにイベントを送信
名前付きイベントとJSON引数をステートマシンに送信し、状態遷移をトリガーします。ステートマシンのバージョンがネームスペースのlowestStateMachineVersionより低い場合、ステータスは自動的に削除されNotFoundエラーが返されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| statusName | string | | ✓| | ~ 36文字 | ステータス名 |
| eventName | string | | ✓| | ~ 36文字 | イベントの名前 |
| args | string | | | "{}" | ~ 4096文字 | ステートマシンに渡す引数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | ステートマシンの状態 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.Emit(
&state_machine.EmitRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
StatusName: pointy.String("status-0001"),
EventName: pointy.String("event-0001"),
Args: pointy.String("{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}"),
}
)
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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\EmitRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->emit(
(new EmitRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withStatusName("status-0001")
->withEventName("event-0001")
->withArgs("{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}")
);
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.EmitRequest;
import io.gs2.stateMachine.result.EmitResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
EmitResult result = client.emit(
new EmitRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withStatusName("status-0001")
.withEventName("event-0001")
.withArgs("{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}")
);
Status 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.Emit(
new Gs2.Gs2StateMachine.Request.EmitRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithStatusName("status-0001")
.WithEventName("event-0001")
.WithArgs("{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}"),
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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.emit(
new Gs2StateMachine.EmitRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withStatusName("status-0001")
.withEventName("event-0001")
.withArgs("{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.emit(
state_machine.EmitRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_status_name('status-0001')
.with_event_name('event-0001')
.with_args('{"value1": "value1", "value2": 2.0, "value3": 3}')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.emit({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
statusName="status-0001",
eventName="event-0001",
args="{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}",
})
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('state_machine')
api_result_handler = client.emit_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
statusName="status-0001",
eventName="event-0001",
args="{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}",
})
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;
```
---
### emitByUserId
ユーザーIDを指定してステートマシンにイベントを送信
指定したユーザーのステートマシンに名前付きイベントとJSON引数を送信し、状態遷移をトリガーします。ステートマシンのバージョンがネームスペースのlowestStateMachineVersionより低い場合、ステータスは自動的に削除されNotFoundエラーが返されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| statusName | string | | ✓| | ~ 36文字 | ステータス名 |
| eventName | string | | ✓| | ~ 36文字 | イベントの名前 |
| args | string | | | "{}" | ~ 4096文字 | ステートマシンに渡す引数 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | ステートマシンの状態 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.EmitByUserId(
&state_machine.EmitByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
StatusName: pointy.String("status-0001"),
EventName: pointy.String("event-0001"),
Args: pointy.String("{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}"),
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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\EmitByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->emitByUserId(
(new EmitByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withStatusName("status-0001")
->withEventName("event-0001")
->withArgs("{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}")
->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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.EmitByUserIdRequest;
import io.gs2.stateMachine.result.EmitByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
EmitByUserIdResult result = client.emitByUserId(
new EmitByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatusName("status-0001")
.withEventName("event-0001")
.withArgs("{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}")
.withTimeOffsetToken(null)
);
Status 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.EmitByUserId(
new Gs2.Gs2StateMachine.Request.EmitByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithStatusName("status-0001")
.WithEventName("event-0001")
.WithArgs("{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}")
.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.emitByUserId(
new Gs2StateMachine.EmitByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatusName("status-0001")
.withEventName("event-0001")
.withArgs("{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.emit_by_user_id(
state_machine.EmitByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_status_name('status-0001')
.with_event_name('event-0001')
.with_args('{"value1": "value1", "value2": 2.0, "value3": 3}')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.emit_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
statusName="status-0001",
eventName="event-0001",
args="{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}",
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('state_machine')
api_result_handler = client.emit_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
statusName="status-0001",
eventName="event-0001",
args="{\"value1\": \"value1\", \"value2\": 2.0, \"value3\": 3}",
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;
```
---
### report
ステートマシンに複数のイベントを報告
投機的実行を使用してクライアント側で処理されたイベントのバッチを報告します。サーバーはイベントをリプレイして状態遷移を検証します。結果の状態がクライアントの報告した状態と一致しない場合、StateMismatchエラーが返されます。ネームスペースで投機的実行が有効になっている必要があります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| statusName | string | | ✓| | ~ 36文字 | ステータス名 |
| events | [List<Event>](#event) | | | | 0 ~ 1000 items | イベントのリスト |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | ステートマシンの状態 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.Report(
&state_machine.ReportRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
StatusName: pointy.String("status-0001"),
Events: []stateMachine.Event{
stateMachine.Event{
EventType: pointy.String("emit"),
EmitEvent: &stateMachine.EmitEvent{
Event: pointy.String("message"),
Parameters: pointy.String("{\"payload\": \"Hello World\"}"),
Timestamp: pointy.Int64(1000),
},
},
},
}
)
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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\ReportRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->report(
(new ReportRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withStatusName("status-0001")
->withEvents([
(new Event())
->withEventType("emit")
->withEmitEvent(
(new EmitEvent())
->withEvent("message")
->withParameters("{\"payload\": \"Hello World\"}")
->withTimestamp(1000)
),
])
);
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.ReportRequest;
import io.gs2.stateMachine.result.ReportResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
ReportResult result = client.report(
new ReportRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withStatusName("status-0001")
.withEvents(Arrays.asList(
new Event()
.withEventType("emit")
.withEmitEvent(
new EmitEvent()
.withEvent("message")
.withParameters("{\"payload\": \"Hello World\"}")
.withTimestamp(1000L)
)
))
);
Status 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.Report(
new Gs2.Gs2StateMachine.Request.ReportRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithStatusName("status-0001")
.WithEvents(new Gs2.Gs2StateMachine.Model.Event[] {
new Gs2.Gs2StateMachine.Model.Event()
.WithEventType("emit")
.WithEmitEvent(
new Gs2.Gs2StateMachine.Model.EmitEvent()
.WithEvent("message")
.WithParameters("{\"payload\": \"Hello World\"}")
.WithTimestamp(1000L)
),
}),
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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.report(
new Gs2StateMachine.ReportRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withStatusName("status-0001")
.withEvents([
new Gs2StateMachine.model.Event()
.withEventType("emit")
.withEmitEvent(
new Gs2StateMachine.model.EmitEvent()
.withEvent("message")
.withParameters("{\"payload\": \"Hello World\"}")
.withTimestamp(1000)
),
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.report(
state_machine.ReportRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_status_name('status-0001')
.with_events([
state_machine.Event()
.with_event_type('emit')
.with_emit_event(
state_machine.EmitEvent()
.with_event('message')
.with_parameters('{"payload": "Hello World"}')
.with_timestamp(1000)
),
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.report({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
statusName="status-0001",
events={
{
event_type="emit",
emit_event=
{
event="message",
parameters="{\"payload\": \"Hello World\"}",
timestamp=1000,
},
}
},
})
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('state_machine')
api_result_handler = client.report_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
statusName="status-0001",
events={
{
event_type="emit",
emit_event=
{
event="message",
parameters="{\"payload\": \"Hello World\"}",
timestamp=1000,
},
}
},
})
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;
```
---
### reportByUserId
ユーザーIDを指定してステートマシンに複数のイベントを報告
指定したユーザーについて、投機的実行を使用してクライアント側で処理されたイベントのバッチを報告します。サーバーはイベントをリプレイして状態遷移を検証します。結果の状態がクライアントの報告した状態と一致しない場合、StateMismatchエラーが返されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| statusName | string | | ✓| | ~ 36文字 | ステータス名 |
| events | [List<Event>](#event) | | | | 0 ~ 1000 items | イベントのリスト |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | ステートマシンの状態 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.ReportByUserId(
&state_machine.ReportByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
StatusName: pointy.String("status-0001"),
Events: []stateMachine.Event{
stateMachine.Event{
EventType: pointy.String("emit"),
EmitEvent: &stateMachine.EmitEvent{
Event: pointy.String("message"),
Parameters: pointy.String("{\"payload\": \"Hello World\"}"),
Timestamp: pointy.Int64(1000),
},
},
},
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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\ReportByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->reportByUserId(
(new ReportByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withStatusName("status-0001")
->withEvents([
(new Event())
->withEventType("emit")
->withEmitEvent(
(new EmitEvent())
->withEvent("message")
->withParameters("{\"payload\": \"Hello World\"}")
->withTimestamp(1000)
),
])
->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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.ReportByUserIdRequest;
import io.gs2.stateMachine.result.ReportByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
ReportByUserIdResult result = client.reportByUserId(
new ReportByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatusName("status-0001")
.withEvents(Arrays.asList(
new Event()
.withEventType("emit")
.withEmitEvent(
new EmitEvent()
.withEvent("message")
.withParameters("{\"payload\": \"Hello World\"}")
.withTimestamp(1000L)
)
))
.withTimeOffsetToken(null)
);
Status 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.ReportByUserId(
new Gs2.Gs2StateMachine.Request.ReportByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithStatusName("status-0001")
.WithEvents(new Gs2.Gs2StateMachine.Model.Event[] {
new Gs2.Gs2StateMachine.Model.Event()
.WithEventType("emit")
.WithEmitEvent(
new Gs2.Gs2StateMachine.Model.EmitEvent()
.WithEvent("message")
.WithParameters("{\"payload\": \"Hello World\"}")
.WithTimestamp(1000L)
),
})
.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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.reportByUserId(
new Gs2StateMachine.ReportByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatusName("status-0001")
.withEvents([
new Gs2StateMachine.model.Event()
.withEventType("emit")
.withEmitEvent(
new Gs2StateMachine.model.EmitEvent()
.withEvent("message")
.withParameters("{\"payload\": \"Hello World\"}")
.withTimestamp(1000)
),
])
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.report_by_user_id(
state_machine.ReportByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_status_name('status-0001')
.with_events([
state_machine.Event()
.with_event_type('emit')
.with_emit_event(
state_machine.EmitEvent()
.with_event('message')
.with_parameters('{"payload": "Hello World"}')
.with_timestamp(1000)
),
])
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.report_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
statusName="status-0001",
events={
{
event_type="emit",
emit_event=
{
event="message",
parameters="{\"payload\": \"Hello World\"}",
timestamp=1000,
},
}
},
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('state_machine')
api_result_handler = client.report_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
statusName="status-0001",
events={
{
event_type="emit",
emit_event=
{
event="message",
parameters="{\"payload\": \"Hello World\"}",
timestamp=1000,
},
}
},
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;
```
---
### deleteStatusByUserId
ユーザーIDを指定してステートマシンの状態を削除
現在の状態（Running、Pass、Error）に関係なく、ステートマシンの状態を強制的に削除します。Exitとは異なり、ステートマシンが終端状態に達している必要はありません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| statusName | string | | ✓| | ~ 36文字 | ステータス名 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 削除したステートマシンの状態 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.DeleteStatusByUserId(
&state_machine.DeleteStatusByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
StatusName: pointy.String("status-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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\DeleteStatusByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->deleteStatusByUserId(
(new DeleteStatusByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withStatusName("status-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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.DeleteStatusByUserIdRequest;
import io.gs2.stateMachine.result.DeleteStatusByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
DeleteStatusByUserIdResult result = client.deleteStatusByUserId(
new DeleteStatusByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatusName("status-0001")
.withTimeOffsetToken(null)
);
Status 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteStatusByUserId(
new Gs2.Gs2StateMachine.Request.DeleteStatusByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithStatusName("status-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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.deleteStatusByUserId(
new Gs2StateMachine.DeleteStatusByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatusName("status-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.delete_status_by_user_id(
state_machine.DeleteStatusByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_status_name('status-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.delete_status_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
statusName="status-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('state_machine')
api_result_handler = client.delete_status_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
statusName="status-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;
```
---
### exitStateMachine
ステートマシンを終了して削除
ステートマシンの状態が「Pass」または「Error」の時にのみ使用できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| statusName | string | | ✓| | ~ 36文字 | ステータス名 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 終了したステートマシンの状態 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.ExitStateMachine(
&state_machine.ExitStateMachineRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
StatusName: pointy.String("status-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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\ExitStateMachineRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->exitStateMachine(
(new ExitStateMachineRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withStatusName("status-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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.ExitStateMachineRequest;
import io.gs2.stateMachine.result.ExitStateMachineResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
ExitStateMachineResult result = client.exitStateMachine(
new ExitStateMachineRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withStatusName("status-0001")
);
Status 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExitStateMachine(
new Gs2.Gs2StateMachine.Request.ExitStateMachineRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithStatusName("status-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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.exitStateMachine(
new Gs2StateMachine.ExitStateMachineRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withStatusName("status-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.exit_state_machine(
state_machine.ExitStateMachineRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_status_name('status-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.exit_state_machine({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
statusName="status-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('state_machine')
api_result_handler = client.exit_state_machine_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
statusName="status-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;
```
---
### exitStateMachineByUserId
ユーザーIDを指定してステートマシンを終了して削除
ステートマシンの状態が「Pass」または「Error」の時にのみ使用できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| statusName | string | | ✓| | ~ 36文字 | ステータス名 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Status](#status) | 終了したステートマシンの状態 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.ExitStateMachineByUserId(
&state_machine.ExitStateMachineByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
StatusName: pointy.String("status-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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\ExitStateMachineByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->exitStateMachineByUserId(
(new ExitStateMachineByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withStatusName("status-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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.ExitStateMachineByUserIdRequest;
import io.gs2.stateMachine.result.ExitStateMachineByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
ExitStateMachineByUserIdResult result = client.exitStateMachineByUserId(
new ExitStateMachineByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatusName("status-0001")
.withTimeOffsetToken(null)
);
Status 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExitStateMachineByUserId(
new Gs2.Gs2StateMachine.Request.ExitStateMachineByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithStatusName("status-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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.exitStateMachineByUserId(
new Gs2StateMachine.ExitStateMachineByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withStatusName("status-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.exit_state_machine_by_user_id(
state_machine.ExitStateMachineByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_status_name('status-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.exit_state_machine_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
statusName="status-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('state_machine')
api_result_handler = client.exit_state_machine_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
statusName="status-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;
```
---
### describeStateMachineMasters
ステートマシンマスターの一覧を取得
ステートマシンマスターのバージョン一覧をページネーション付きで取得します。各バージョンにはメインステートマシン名とステートマシンロジックを定義するGS2 Scriptペイロードが含まれます。タイムスタンプベースのバージョン番号で識別される複数のバージョンが同時に存在できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<StateMachineMaster>](#statemachinemaster) | ステートマシンマスターのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.DescribeStateMachineMasters(
&state_machine.DescribeStateMachineMastersRequest {
NamespaceName: pointy.String("namespace-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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\DescribeStateMachineMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->describeStateMachineMasters(
(new DescribeStateMachineMastersRequest())
->withNamespaceName("namespace-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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.DescribeStateMachineMastersRequest;
import io.gs2.stateMachine.result.DescribeStateMachineMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
DescribeStateMachineMastersResult result = client.describeStateMachineMasters(
new DescribeStateMachineMastersRequest()
.withNamespaceName("namespace-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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeStateMachineMasters(
new Gs2.Gs2StateMachine.Request.DescribeStateMachineMastersRequest()
.WithNamespaceName("namespace-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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.describeStateMachineMasters(
new Gs2StateMachine.DescribeStateMachineMastersRequest()
.withNamespaceName("namespace-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 state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.describe_state_machine_masters(
state_machine.DescribeStateMachineMastersRequest()
.with_namespace_name('namespace-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('state_machine')
api_result = client.describe_state_machine_masters({
namespaceName="namespace-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('state_machine')
api_result_handler = client.describe_state_machine_masters_async({
namespaceName="namespace-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;
```
---
### updateStateMachineMaster
ステートマシンマスターを作成または更新
ステートマシンマスターの新しいバージョンを作成します。GS2 Scriptステートマシン定義を含むペイロードは保存前にパース検証されます。このAPIを呼び出すたびにタイムスタンプベースのバージョン番号で新しいバージョンが作成され、以前のバージョンは保持されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| mainStateMachineName | string | | ✓| | ~ 128文字 | メインステートマシン名
GSL 定義内のエントリポイントとなるステートマシンの名前です。このステートマシンから実行が開始され、スタック機構を通じてサブステートマシンを呼び出すことができます。 |
| payload | string | | ✓| | ~ 5242880文字 | ステートマシン定義
ステートマシンの状態、遷移、アクションを定義する GSL（GS2 State Language）のソースコードです。効率的な取得のためにメタデータとは別に保存されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [StateMachineMaster](#statemachinemaster) | 作成したステートマシンマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.UpdateStateMachineMaster(
&state_machine.UpdateStateMachineMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
MainStateMachineName: pointy.String("MainStateMachine"),
Payload: pointy.String("\nStateMachine MainStateMachine {\n EntryPoint Task1;\n\n Task Task1(int initCounter) {\n Event Pass();\n Event Error(string Reason);\n\n Script grn:gs2:ap-northeast-1:YourOwnerId:script:state-machine-0001:script:Task1\n }\n\n PassTask Pass;\n\n ErrorTask Error(string reason);\n\n Transition Task1 handling Pass -> Pass;\n Transition Task1 handling Error -> Error;\n}\n "),
}
)
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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\UpdateStateMachineMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->updateStateMachineMaster(
(new UpdateStateMachineMasterRequest())
->withNamespaceName("namespace-0001")
->withMainStateMachineName("MainStateMachine")
->withPayload("\nStateMachine MainStateMachine {\n EntryPoint Task1;\n\n Task Task1(int initCounter) {\n Event Pass();\n Event Error(string Reason);\n\n Script grn:gs2:ap-northeast-1:YourOwnerId:script:state-machine-0001:script:Task1\n }\n\n PassTask Pass;\n\n ErrorTask Error(string reason);\n\n Transition Task1 handling Pass -> Pass;\n Transition Task1 handling Error -> Error;\n}\n ")
);
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.UpdateStateMachineMasterRequest;
import io.gs2.stateMachine.result.UpdateStateMachineMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
UpdateStateMachineMasterResult result = client.updateStateMachineMaster(
new UpdateStateMachineMasterRequest()
.withNamespaceName("namespace-0001")
.withMainStateMachineName("MainStateMachine")
.withPayload("\nStateMachine MainStateMachine {\n EntryPoint Task1;\n\n Task Task1(int initCounter) {\n Event Pass();\n Event Error(string Reason);\n\n Script grn:gs2:ap-northeast-1:YourOwnerId:script:state-machine-0001:script:Task1\n }\n\n PassTask Pass;\n\n ErrorTask Error(string reason);\n\n Transition Task1 handling Pass -> Pass;\n Transition Task1 handling Error -> Error;\n}\n ")
);
StateMachineMaster 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateStateMachineMaster(
new Gs2.Gs2StateMachine.Request.UpdateStateMachineMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMainStateMachineName("MainStateMachine")
.WithPayload("\nStateMachine MainStateMachine {\n EntryPoint Task1;\n\n Task Task1(int initCounter) {\n Event Pass();\n Event Error(string Reason);\n\n Script grn:gs2:ap-northeast-1:YourOwnerId:script:state-machine-0001:script:Task1\n }\n\n PassTask Pass;\n\n ErrorTask Error(string reason);\n\n Transition Task1 handling Pass -> Pass;\n Transition Task1 handling Error -> Error;\n}\n "),
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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.updateStateMachineMaster(
new Gs2StateMachine.UpdateStateMachineMasterRequest()
.withNamespaceName("namespace-0001")
.withMainStateMachineName("MainStateMachine")
.withPayload("\nStateMachine MainStateMachine {\n EntryPoint Task1;\n\n Task Task1(int initCounter) {\n Event Pass();\n Event Error(string Reason);\n\n Script grn:gs2:ap-northeast-1:YourOwnerId:script:state-machine-0001:script:Task1\n }\n\n PassTask Pass;\n\n ErrorTask Error(string reason);\n\n Transition Task1 handling Pass -> Pass;\n Transition Task1 handling Error -> Error;\n}\n ")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.update_state_machine_master(
state_machine.UpdateStateMachineMasterRequest()
.with_namespace_name('namespace-0001')
.with_main_state_machine_name('MainStateMachine')
.with_payload('\nStateMachine MainStateMachine {\n EntryPoint Task1;\n\n Task Task1(int initCounter) {\n Event Pass();\n Event Error(string Reason);\n\n Script grn:gs2:ap-northeast-1:YourOwnerId:script:state-machine-0001:script:Task1\n }\n\n PassTask Pass;\n\n ErrorTask Error(string reason);\n\n Transition Task1 handling Pass -> Pass;\n Transition Task1 handling Error -> Error;\n}\n ')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.update_state_machine_master({
namespaceName="namespace-0001",
mainStateMachineName="MainStateMachine",
payload="\nStateMachine MainStateMachine {\n EntryPoint Task1;\n\n Task Task1(int initCounter) {\n Event Pass();\n Event Error(string Reason);\n\n Script grn:gs2:ap-northeast-1:YourOwnerId:script:state-machine-0001:script:Task1\n }\n\n PassTask Pass;\n\n ErrorTask Error(string reason);\n\n Transition Task1 handling Pass -> Pass;\n Transition Task1 handling Error -> Error;\n}\n ",
})
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('state_machine')
api_result_handler = client.update_state_machine_master_async({
namespaceName="namespace-0001",
mainStateMachineName="MainStateMachine",
payload="\nStateMachine MainStateMachine {\n EntryPoint Task1;\n\n Task Task1(int initCounter) {\n Event Pass();\n Event Error(string Reason);\n\n Script grn:gs2:ap-northeast-1:YourOwnerId:script:state-machine-0001:script:Task1\n }\n\n PassTask Pass;\n\n ErrorTask Error(string reason);\n\n Transition Task1 handling Pass -> Pass;\n Transition Task1 handling Error -> Error;\n}\n ",
})
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;
```
---
### getStateMachineMaster
ステートマシンマスターを取得
ステートマシンロジックを定義するメインステートマシン名とGS2 Scriptペイロードを含む、指定されたバージョンのステートマシンマスターを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| version | long | | ✓| | 0 ~ 32503680000000 | バージョン
このステートマシン定義のバージョン識別子です。作成時に自動的に割り当てられます。ネームスペースの lowestStateMachineVersion と組み合わせて、実行中インスタンスのバージョン互換性を強制するために使用されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [StateMachineMaster](#statemachinemaster) | ステートマシンマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.GetStateMachineMaster(
&state_machine.GetStateMachineMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Version: pointy.Int64(1000),
}
)
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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\GetStateMachineMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->getStateMachineMaster(
(new GetStateMachineMasterRequest())
->withNamespaceName("namespace-0001")
->withVersion(1000)
);
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.GetStateMachineMasterRequest;
import io.gs2.stateMachine.result.GetStateMachineMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
GetStateMachineMasterResult result = client.getStateMachineMaster(
new GetStateMachineMasterRequest()
.withNamespaceName("namespace-0001")
.withVersion(1000L)
);
StateMachineMaster 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetStateMachineMaster(
new Gs2.Gs2StateMachine.Request.GetStateMachineMasterRequest()
.WithNamespaceName("namespace-0001")
.WithVersion(1000L),
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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.getStateMachineMaster(
new Gs2StateMachine.GetStateMachineMasterRequest()
.withNamespaceName("namespace-0001")
.withVersion(1000)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.get_state_machine_master(
state_machine.GetStateMachineMasterRequest()
.with_namespace_name('namespace-0001')
.with_version(1000)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.get_state_machine_master({
namespaceName="namespace-0001",
version=1000,
})
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('state_machine')
api_result_handler = client.get_state_machine_master_async({
namespaceName="namespace-0001",
version=1000,
})
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;
```
---
### deleteStateMachineMaster
ステートマシンマスターを削除
指定されたバージョンのステートマシンマスターを削除します。このバージョンで開始済みの実行中のステートマシンは引き続き動作しますが、削除されたバージョンで新しいステートマシンを開始することはできません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| version | long | | ✓| | 0 ~ 32503680000000 | バージョン
このステートマシン定義のバージョン識別子です。作成時に自動的に割り当てられます。ネームスペースの lowestStateMachineVersion と組み合わせて、実行中インスタンスのバージョン互換性を強制するために使用されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [StateMachineMaster](#statemachinemaster) | 削除したステートマシンマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/stateMachine"
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 := state_machine.Gs2StateMachineRestClient{
Session: &session,
}
result, err := client.DeleteStateMachineMaster(
&state_machine.DeleteStateMachineMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Version: pointy.Int64(1000),
}
)
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\StateMachine\Gs2StateMachineRestClient;
use Gs2\StateMachine\Request\DeleteStateMachineMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2StateMachineRestClient(
$session
);
try {
$result = $client->deleteStateMachineMaster(
(new DeleteStateMachineMasterRequest())
->withNamespaceName("namespace-0001")
->withVersion(1000)
);
$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.stateMachine.rest.Gs2StateMachineRestClient;
import io.gs2.stateMachine.request.DeleteStateMachineMasterRequest;
import io.gs2.stateMachine.result.DeleteStateMachineMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session);
try {
DeleteStateMachineMasterResult result = client.deleteStateMachineMaster(
new DeleteStateMachineMasterRequest()
.withNamespaceName("namespace-0001")
.withVersion(1000L)
);
StateMachineMaster 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 Gs2StateMachineRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteStateMachineMaster(
new Gs2.Gs2StateMachine.Request.DeleteStateMachineMasterRequest()
.WithNamespaceName("namespace-0001")
.WithVersion(1000L),
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 Gs2StateMachine from '@/gs2/stateMachine';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2StateMachine.Gs2StateMachineRestClient(session);
try {
const result = await client.deleteStateMachineMaster(
new Gs2StateMachine.DeleteStateMachineMasterRequest()
.withNamespaceName("namespace-0001")
.withVersion(1000)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import state_machine
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = state_machine.Gs2StateMachineRestClient(session)
try:
result = client.delete_state_machine_master(
state_machine.DeleteStateMachineMasterRequest()
.with_namespace_name('namespace-0001')
.with_version(1000)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('state_machine')
api_result = client.delete_state_machine_master({
namespaceName="namespace-0001",
version=1000,
})
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('state_machine')
api_result_handler = client.delete_state_machine_master_async({
namespaceName="namespace-0001",
version=1000,
})
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;
```
---