GS2-StateMachine SDK API リファレンス

各種プログラミング言語向け GS2-SDK の モデルの仕様 と API のリファレンス

モデル

Namespace

ネームスペース

ネームスペースは一つのプロジェクトで同じサービスを異なる用途で複数利用できるようにするための仕組みです。
GS2 のサービスは基本的にネームスペースというレイヤーがあり、ネームスペースが異なれば同じサービスでもまったく別のデータ空間として取り扱われます。

そのため、各サービスの利用を開始するにあたってネームスペースを作成する必要があります。

有効化条件必須デフォルト値の制限説明
namespaceIdstring~ 1024文字ネームスペースGRN
namestring~ 128文字ネームスペース名
descriptionstring~ 1024文字説明文
supportSpeculativeExecutionenum {
    “enable”,
    “disable”
}
“disable”~ 128文字投機的実行をサポートするか
transactionSettingTransactionSetting{supportSpeculativeExecution} == “enable”トランザクション設定
startScriptScriptSettingステートマシンを起動した時に実行するスクリプト
passScriptScriptSettingステートマシンが正常終了した時に実行するスクリプト
errorScriptScriptSettingステートマシンが異常終了した時に実行するスクリプト
lowestStateMachineVersionlongステートマシンの最低バージョン (UNIX時間 単位:ミリ秒)
logSettingLogSettingログの出力設定
createdAtlong現在時刻作成日時 (UNIX時間 単位:ミリ秒)
updatedAtlong現在時刻最終更新日時 (UNIX時間 単位:ミリ秒)
revisionlong0~ 9223372036854775805リビジョン

supportSpeculativeExecution に指定する列挙型の定義

定義説明
enable有効
disable無効

StateMachineMaster

ステートマシン定義

GSLで記述されたステートマシンを管理します。

有効化条件必須デフォルト値の制限説明
stateMachineIdstring~ 1024文字ステートマシンマスターGRN
mainStateMachineNamestring~ 128文字メインステートマシン名
payloadstring~ 5242880文字ステートマシン定義
versionlong~ 32503680000000バージョン
createdAtlong現在時刻作成日時 (UNIX時間 単位:ミリ秒)
updatedAtlong現在時刻最終更新日時 (UNIX時間 単位:ミリ秒)
revisionlong0~ 9223372036854775805リビジョン

Status

ステートマシンの状態

有効化条件必須デフォルト値の制限説明
statusIdstring~ 1024文字ステートマシンの状態GRN
userIdstring~ 128文字ユーザーID
namestringUUID~ 36文字ステータス名
stateMachineVersionlong~ 32503680000000バージョン
enableSpeculativeExecutionenum {
    “enable”,
    “disable”
}
“disable”~ 128文字投機的実行を有効にするか
stateMachineDefinitionstring{enableSpeculativeExecution} == “enable”~ 16777216文字ステートマシン定義
randomStatusRandomStatus{enableSpeculativeExecution} == “enable”乱数状態
stacksList<StackEntry>[]~ 1024 itemsスタック
variablesList<Variable>[]~ 1000 itemsステートマシンごとの状態変数
statusenum {
    “Running”,
    “Wait”,
    “Pass”,
    “Error”
}
“Running”~ 128文字ステータス
lastErrorstring~ 1024文字最後のエラー
transitionCountint0~ 2147483645遷移回数
createdAtlong現在時刻作成日時 (UNIX時間 単位:ミリ秒)
updatedAtlong現在時刻最終更新日時 (UNIX時間 単位:ミリ秒)

enableSpeculativeExecution に指定する列挙型の定義

定義説明
enable有効
disable無効

status に指定する列挙型の定義

定義説明
Running実行中
Wait待機中
Pass終了
Errorエラー

StackEntry

スタック

有効化条件必須デフォルト値の制限説明
stateMachineNamestring~ 128文字ステートマシン名
taskNamestring~ 128文字タスク名

Variable

ステートマシンごとの状態変数

有効化条件必須デフォルト値の制限説明
stateMachineNamestring~ 128文字ステートマシン名
valuestring~ 1048576文字

TransactionSetting

トランザクション設定

有効化条件必須デフォルト値の制限説明
enableAutoRunboolfalse発行したトランザクションをサーバーサイドで自動的に実行するか
enableAtomicCommitbool{enableAutoRun} == truefalseトランザクションの実行をアトミックにコミットするか
transactionUseDistributorbool{enableAtomicCommit} == truefalseトランザクションを非同期処理で実行する
acquireActionUseJobQueuebool{enableAtomicCommit} == truefalse入手アクションを実行する際に GS2-JobQueue を使用するか
distributorNamespaceIdstring“grn:gs2:{region}:{ownerId}:distributor:default”~ 1024文字トランザクションの実行に使用する GS2-Distributor ネームスペース
queueNamespaceIdstring“grn:gs2:{region}:{ownerId}:queue:default”~ 1024文字トランザクションの実行に使用する GS2-JobQueue のネームスペース

Event

イベント

有効化条件必須デフォルト値の制限説明
eventTypeenum {
    “change_state”,
    “emit”
}
~ 128文字イベントの種類
changeStateEventChangeStateEvent{eventType} == “change_state”ステートの変更
emitEventEmitEvent{eventType} == “emit”メッセージの送信

eventType に指定する列挙型の定義

定義説明
change_stateステートの変更
emitメッセージの送信

ChangeStateEvent

ステートの変更イベント

有効化条件必須デフォルト値の制限説明
taskNamestring~ 128文字タスク名
hashstring~ 64文字ハッシュ
timestamplongタイムスタンプ (UNIX時間 単位:ミリ秒)

EmitEvent

メッセージの送信イベント

有効化条件必須デフォルト値の制限説明
eventstring~ 128文字イベント名
parametersstring~ 1024文字パラメータ
timestamplongタイムスタンプ (UNIX時間 単位:ミリ秒)

RandomStatus

乱数の状態

有効化条件必須デフォルト値の制限説明
seedlong~ 4294967294乱数シード
usedList<RandomUsed>~ 1000 items使用済み乱数リスト

RandomUsed

使用済み乱数

有効化条件必須デフォルト値の制限説明
categorylong~ 4294967294カテゴリ
usedlong~ 4294967294使用済み乱数

VerifyActionResult

検証アクションの実行結果

有効化条件必須デフォルト値の制限説明
actionenum {
}
~ 128文字検証アクションで実行するアクションの種類
verifyRequeststring~ 1048576文字リクエストのJSON
statusCodeint~ 999ステータスコード
verifyResultstring~ 1048576文字結果内容

action に指定する列挙型の定義

定義説明

ConsumeActionResult

消費アクションの実行結果

有効化条件必須デフォルト値の制限説明
actionenum {
}
~ 128文字消費アクションで実行するアクションの種類
consumeRequeststring~ 1048576文字リクエストのJSON
statusCodeint~ 999ステータスコード
consumeResultstring~ 1048576文字結果内容

action に指定する列挙型の定義

定義説明

AcquireActionResult

入手アクションの実行結果

有効化条件必須デフォルト値の制限説明
actionenum {
}
~ 128文字入手アクションで実行するアクションの種類
acquireRequeststring~ 1048576文字リクエストのJSON
statusCodeint~ 999ステータスコード
acquireResultstring~ 1048576文字結果内容

action に指定する列挙型の定義

定義説明

TransactionResult

トランザクション実行結果

サーバーサイドでのトランザクションの自動実行機能を利用して実行されたトランザクションの実行結果

有効化条件必須デフォルト値の制限説明
transactionIdstring36 ~ 36文字トランザクションID
verifyResultsList<VerifyActionResult>~ 10 items検証アクションの実行結果リスト
consumeResultsList<ConsumeActionResult>[]~ 10 items消費アクションの実行結果リスト
acquireResultsList<AcquireActionResult>[]~ 100 items入手アクションの実行結果リスト

LogSetting

ログの書き出し設定

ログデータの書き出し設定を管理します。この型は、ログデータを書き出すために使用されるログ名前空間の識別子(Namespace ID)を保持します。
ログ名前空間IDは、ログデータを集約し、保存する対象の GS2-Log の名前空間を指定します。
この設定を通じて、この名前空間以下のAPIリクエスト・レスポンスログデータが対象の GS2-Log へ出力されるようになります。
GS2-Log にはリアルタイムでログが提供され、システムの監視や分析、デバッグなどに利用できます。

有効化条件必須デフォルト値の制限説明
loggingNamespaceIdstring~ 1024文字ネームスペースGRN

ScriptSetting

スクリプト設定

GS2 ではマイクロサービスのイベントに関連づけて、カスタムスクリプトを実行することができます。
このモデルは、スクリプトの実行をトリガーするための設定を保持します。

スクリプトの実行方式は大きく2種類あり、それは「同期実行」と「非同期実行」です。
同期実行は、スクリプトの実行が完了するまで処理がブロックされます。
かわりに、スクリプトの実行結果を使ってAPIの実行を止めたり、APIの結果を改ざんすることができます。

一方、非同期実行は、スクリプトの実行が完了するまで処理がブロックされません。
かわりに、スクリプトの実行結果を使ってAPIの実行を止めたり、APIの結果を改ざんすることはできません。
しかし、非同期実行は、スクリプトの実行が完了するまで処理がブロックされないため、APIの応答に影響を与えないため、原則非同期実行を使用することをおすすめします。

非同期実行には実行方式が2種類あり、GS2-Script と Amazon EventBridge があります。
Amazon EventBridge を使用することで、Lua 以外の言語で処理を記述することができます。

有効化条件必須デフォルト値の制限説明
triggerScriptIdstring~ 1024文字スクリプトGRN
doneTriggerTargetTypeenum {
    “none”,
    “gs2_script”,
    “aws”
}
“none”~ 128文字完了通知の通知先
doneTriggerScriptIdstring{doneTriggerTargetType} == “gs2_script”~ 1024文字スクリプトGRN
doneTriggerQueueNamespaceIdstring{doneTriggerTargetType} == “gs2_script”~ 1024文字ネームスペースGRN

doneTriggerTargetType に指定する列挙型の定義

定義説明
noneなし
gs2_scriptGS2-Script
awsAmazon EventBridge

メソッド

describeNamespaces

ネームスペースの一覧を取得

Request

有効化条件必須デフォルト値の制限説明
pageTokenstring~ 1024文字データの取得を開始する位置を指定するトークン
limitint301 ~ 1000データの取得件数

Result

説明
itemsList<Namespace>ネームスペースのリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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 { PageToken: nil, Limit: nil, } ) if err != nil { panic("error occurred") } items := result.Items nextPageToken := result.NextPageToken
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 Gs2AccountRestClient( $session ); try { $result = $client->describeNamespaces( (new DescribeNamespacesRequest()) ->withPageToken(null) ->withLimit(null) ); $items = $result->getItems(); $nextPageToken = $result->getNextPageToken(); } catch (Gs2Exception $e) { exit("error occurred") }
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() .withPageToken(null) .withLimit(null) ); List<Namespace> items = result.getItems(); String nextPageToken = result.getNextPageToken(); } catch (Gs2Exception e) { System.exit(1); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.DescribeNamespacesRequest; using Gs2.Gs2StateMachine.Result.DescribeNamespacesResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.DescribeNamespacesResult> asyncResult = null; yield return client.DescribeNamespaces( new Gs2.Gs2StateMachine.Request.DescribeNamespacesRequest() .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;
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() .withPageToken(null) .withLimit(null) ); const items = result.getItems(); const nextPageToken = result.getNextPageToken(); } catch (e) { process.exit(1); }
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_page_token(None) .with_limit(None) ) items = result.items next_page_token = result.next_page_token except core.Gs2Exception as e: exit(1)
client = gs2('state_machine') api_result = client.describe_namespaces({ pageToken=nil, limit=nil, }) if(api_result.isError) then -- When error occurs fail(api_result['statusCode'], api_result['message']) end result = api_result.result items = result.items; nextPageToken = result.nextPageToken;
client = gs2('state_machine') api_result_handler = client.describe_namespaces_async({ 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['message']) end result = api_result.result items = result.items; nextPageToken = result.nextPageToken;

createNamespace

ネームスペースを新規作成

Request

有効化条件必須デフォルト値の制限説明
namestring~ 128文字ネームスペース名
descriptionstring~ 1024文字説明文
supportSpeculativeExecutionenum {
    “enable”,
    “disable”
}
“disable”~ 128文字投機的実行をサポートするか
transactionSettingTransactionSetting{supportSpeculativeExecution} == “enable”トランザクション設定
startScriptScriptSettingステートマシンを起動した時に実行するスクリプト
passScriptScriptSettingステートマシンが正常終了した時に実行するスクリプト
errorScriptScriptSettingステートマシンが異常終了した時に実行するスクリプト
lowestStateMachineVersionlongステートマシンの最低バージョン (UNIX時間 単位:ミリ秒)
logSettingLogSettingログの出力設定

supportSpeculativeExecution に指定する列挙型の定義

定義説明
enable有効
disable無効

Result

説明
itemNamespace作成したネームスペース

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.CreateNamespaceRequest; using Gs2.Gs2StateMachine.Result.CreateNamespaceResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.CreateNamespaceResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

getNamespaceStatus

ネームスペースの状態を取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名

Result

説明
statusstring

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $session ); try { $result = $client->getNamespaceStatus( (new GetNamespaceStatusRequest()) ->withNamespaceName("namespace-0001") ); $status = $result->getStatus(); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.GetNamespaceStatusRequest; using Gs2.Gs2StateMachine.Result.GetNamespaceStatusResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.GetNamespaceStatusResult> 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;
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); }
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)
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['message']) end result = api_result.result status = result.status;
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['message']) end result = api_result.result status = result.status;

getNamespace

ネームスペースを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名

Result

説明
itemNamespaceネームスペース

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $session ); try { $result = $client->getNamespace( (new GetNamespaceRequest()) ->withNamespaceName("namespace-0001") ); $item = $result->getItem(); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.GetNamespaceRequest; using Gs2.Gs2StateMachine.Result.GetNamespaceResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.GetNamespaceResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

updateNamespace

ネームスペースを更新

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
descriptionstring~ 1024文字説明文
supportSpeculativeExecutionenum {
    “enable”,
    “disable”
}
“disable”~ 128文字投機的実行をサポートするか
transactionSettingTransactionSetting{supportSpeculativeExecution} == “enable”トランザクション設定
startScriptScriptSettingステートマシンを起動した時に実行するスクリプト
passScriptScriptSettingステートマシンが正常終了した時に実行するスクリプト
errorScriptScriptSettingステートマシンが異常終了した時に実行するスクリプト
lowestStateMachineVersionlongステートマシンの最低バージョン (UNIX時間 単位:ミリ秒)
logSettingLogSettingログの出力設定

supportSpeculativeExecution に指定する列挙型の定義

定義説明
enable有効
disable無効

Result

説明
itemNamespace更新したネームスペース

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.UpdateNamespaceRequest; using Gs2.Gs2StateMachine.Result.UpdateNamespaceResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.UpdateNamespaceResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

deleteNamespace

ネームスペースを削除

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名

Result

説明
itemNamespace削除したネームスペース

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $session ); try { $result = $client->deleteNamespace( (new DeleteNamespaceRequest()) ->withNamespaceName("namespace-0001") ); $item = $result->getItem(); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.DeleteNamespaceRequest; using Gs2.Gs2StateMachine.Result.DeleteNamespaceResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.DeleteNamespaceResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

dumpUserDataByUserId

指定したユーザーIDに紐づくデータのダンプを取得

Request

有効化条件必須デフォルト値の制限説明
userIdstring~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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") }
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 Gs2AccountRestClient( $session ); try { $result = $client->dumpUserDataByUserId( (new DumpUserDataByUserIdRequest()) ->withUserId("user-0001") ->withTimeOffsetToken(null) ); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.DumpUserDataByUserIdRequest; using Gs2.Gs2StateMachine.Result.DumpUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.DumpUserDataByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result
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['message']) end result = api_result.result

checkDumpUserDataByUserId

指定したユーザーIDに紐づくデータのダンプが完了しているか確認

Request

有効化条件必須デフォルト値の制限説明
userIdstring~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
urlstring出力データのURL

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $session ); try { $result = $client->checkDumpUserDataByUserId( (new CheckDumpUserDataByUserIdRequest()) ->withUserId("user-0001") ->withTimeOffsetToken(null) ); $url = $result->getUrl(); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.CheckDumpUserDataByUserIdRequest; using Gs2.Gs2StateMachine.Result.CheckDumpUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.CheckDumpUserDataByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result url = result.url;
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['message']) end result = api_result.result url = result.url;

cleanUserDataByUserId

指定したユーザーIDに紐づくデータのダンプを取得

Request

有効化条件必須デフォルト値の制限説明
userIdstring~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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") }
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 Gs2AccountRestClient( $session ); try { $result = $client->cleanUserDataByUserId( (new CleanUserDataByUserIdRequest()) ->withUserId("user-0001") ->withTimeOffsetToken(null) ); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.CleanUserDataByUserIdRequest; using Gs2.Gs2StateMachine.Result.CleanUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.CleanUserDataByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result
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['message']) end result = api_result.result

checkCleanUserDataByUserId

指定したユーザーIDに紐づくデータのダンプが完了しているか確認

Request

有効化条件必須デフォルト値の制限説明
userIdstring~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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") }
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 Gs2AccountRestClient( $session ); try { $result = $client->checkCleanUserDataByUserId( (new CheckCleanUserDataByUserIdRequest()) ->withUserId("user-0001") ->withTimeOffsetToken(null) ); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.CheckCleanUserDataByUserIdRequest; using Gs2.Gs2StateMachine.Result.CheckCleanUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.CheckCleanUserDataByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result
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['message']) end result = api_result.result

prepareImportUserDataByUserId

指定したユーザーIDに紐づくデータのインポートを開始

Request

有効化条件必須デフォルト値の制限説明
userIdstring~ 128文字ユーザーID
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
uploadTokenstringアップロード後に結果を反映する際に使用するトークン
uploadUrlstringユーザーデータアップロード処理の実行に使用するURL

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $session ); try { $result = $client->prepareImportUserDataByUserId( (new PrepareImportUserDataByUserIdRequest()) ->withUserId("user-0001") ->withTimeOffsetToken(null) ); $uploadToken = $result->getUploadToken(); $uploadUrl = $result->getUploadUrl(); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.PrepareImportUserDataByUserIdRequest; using Gs2.Gs2StateMachine.Result.PrepareImportUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.PrepareImportUserDataByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result uploadToken = result.uploadToken; uploadUrl = result.uploadUrl;
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['message']) end result = api_result.result uploadToken = result.uploadToken; uploadUrl = result.uploadUrl;

importUserDataByUserId

指定したユーザーIDに紐づくデータのインポートを開始

Request

有効化条件必須デフォルト値の制限説明
userIdstring~ 128文字ユーザーID
uploadTokenstring~ 1024文字アップロード準備で受け取ったトークン
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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") }
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 Gs2AccountRestClient( $session ); try { $result = $client->importUserDataByUserId( (new ImportUserDataByUserIdRequest()) ->withUserId("user-0001") ->withUploadToken("upload-0001") ->withTimeOffsetToken(null) ); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.ImportUserDataByUserIdRequest; using Gs2.Gs2StateMachine.Result.ImportUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.ImportUserDataByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result
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['message']) end result = api_result.result

checkImportUserDataByUserId

指定したユーザーIDに紐づくデータのインポートが完了しているか確認

Request

有効化条件必須デフォルト値の制限説明
userIdstring~ 128文字ユーザーID
uploadTokenstring~ 1024文字アップロード準備で受け取ったトークン
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
urlstring出力ログのURL

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $session ); try { $result = $client->checkImportUserDataByUserId( (new CheckImportUserDataByUserIdRequest()) ->withUserId("user-0001") ->withUploadToken("upload-0001") ->withTimeOffsetToken(null) ); $url = $result->getUrl(); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.CheckImportUserDataByUserIdRequest; using Gs2.Gs2StateMachine.Result.CheckImportUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.CheckImportUserDataByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result url = result.url;
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['message']) end result = api_result.result url = result.url;

describeStateMachineMasters

ステートマシンマスターの一覧を取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
pageTokenstring~ 1024文字データの取得を開始する位置を指定するトークン
limitint301 ~ 1000データの取得件数

Result

説明
itemsList<StateMachineMaster>ステートマシンマスターのリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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<StateMachineMaster> items = result.getItems(); String nextPageToken = result.getNextPageToken(); } catch (Gs2Exception e) { System.exit(1); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.DescribeStateMachineMastersRequest; using Gs2.Gs2StateMachine.Result.DescribeStateMachineMastersResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.DescribeStateMachineMastersResult> 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;
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); }
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)
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['message']) end result = api_result.result items = result.items; nextPageToken = result.nextPageToken;
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['message']) end result = api_result.result items = result.items; nextPageToken = result.nextPageToken;

updateStateMachineMaster

ステートマシンマスターを新規作成

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
mainStateMachineNamestring~ 128文字メインステートマシン名
payloadstring~ 5242880文字ステートマシン定義

Result

説明
itemStateMachineMaster作成したステートマシンマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.UpdateStateMachineMasterRequest; using Gs2.Gs2StateMachine.Result.UpdateStateMachineMasterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.UpdateStateMachineMasterResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

getStateMachineMaster

ステートマシンマスターを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
versionlong~ 32503680000000バージョン

Result

説明
itemStateMachineMasterステートマシンマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $session ); try { $result = $client->getStateMachineMaster( (new GetStateMachineMasterRequest()) ->withNamespaceName("namespace-0001") ->withVersion(1000) ); $item = $result->getItem(); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.GetStateMachineMasterRequest; using Gs2.Gs2StateMachine.Result.GetStateMachineMasterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.GetStateMachineMasterResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

deleteStateMachineMaster

ステートマシンマスターを削除

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
versionlong~ 32503680000000バージョン

Result

説明
itemStateMachineMaster削除したステートマシンマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $session ); try { $result = $client->deleteStateMachineMaster( (new DeleteStateMachineMasterRequest()) ->withNamespaceName("namespace-0001") ->withVersion(1000) ); $item = $result->getItem(); } catch (Gs2Exception $e) { exit("error occurred") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.DeleteStateMachineMasterRequest; using Gs2.Gs2StateMachine.Result.DeleteStateMachineMasterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.DeleteStateMachineMasterResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

describeStatuses

ステートマシンの状態のリストを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
accessTokenstring~ 128文字アクセストークン
statusenum {
    “Running”,
    “Wait”,
    “Pass”,
    “Error”
}
~ 128文字ステータス
pageTokenstring~ 1024文字データの取得を開始する位置を指定するトークン
limitint301 ~ 1000データの取得件数

status に指定する列挙型の定義

定義説明
Running実行中
Wait待機中
Pass終了
Errorエラー

Result

説明
itemsList<Status>ステートマシンの状態のリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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<Status> items = result.getItems(); String nextPageToken = result.getNextPageToken(); } catch (Gs2Exception e) { System.exit(1); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.DescribeStatusesRequest; using Gs2.Gs2StateMachine.Result.DescribeStatusesResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.DescribeStatusesResult> 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;
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); }
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)
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['message']) end result = api_result.result items = result.items; nextPageToken = result.nextPageToken;
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['message']) end result = api_result.result items = result.items; nextPageToken = result.nextPageToken;

describeStatusesByUserId

ユーザーIDを指定してステートマシンの状態のリストを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
userIdstring~ 128文字ユーザーID
statusenum {
    “Running”,
    “Wait”,
    “Pass”,
    “Error”
}
~ 128文字ステータス
pageTokenstring~ 1024文字データの取得を開始する位置を指定するトークン
limitint301 ~ 1000データの取得件数
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

status に指定する列挙型の定義

定義説明
Running実行中
Wait待機中
Pass終了
Errorエラー

Result

説明
itemsList<Status>ステートマシンの状態のリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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<Status> items = result.getItems(); String nextPageToken = result.getNextPageToken(); } catch (Gs2Exception e) { System.exit(1); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.DescribeStatusesByUserIdRequest; using Gs2.Gs2StateMachine.Result.DescribeStatusesByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.DescribeStatusesByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result items = result.items; nextPageToken = result.nextPageToken;
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['message']) end result = api_result.result items = result.items; nextPageToken = result.nextPageToken;

getStatus

ステートマシンを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
accessTokenstring~ 128文字アクセストークン
statusNamestring~ 36文字ステータス名

Result

説明
itemStatusステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.GetStatusRequest; using Gs2.Gs2StateMachine.Result.GetStatusResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.GetStatusResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

getStatusByUserId

ユーザIDを指定してステートマシンを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
userIdstring~ 128文字ユーザーID
statusNamestring~ 36文字ステータス名
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemStatusステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.GetStatusByUserIdRequest; using Gs2.Gs2StateMachine.Result.GetStatusByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.GetStatusByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

startStateMachineByUserId

ユーザIDを指定してステートマシンを開始

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
userIdstring~ 128文字ユーザーID
argsstring“{}”~ 4096文字ステートマシンに渡す引数
ttlint1 ~ 525600有効期間(分)
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemStatus開始したのステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.StartStateMachineByUserIdRequest; using Gs2.Gs2StateMachine.Result.StartStateMachineByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.StartStateMachineByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

startStateMachineByStampSheet

入手アクションとしてステートマシンの開始を実行

Request

有効化条件必須デフォルト値の制限説明
stampSheetstring~ 5242880文字トランザクション
keyIdstring~ 1024文字暗号鍵GRN

Result

説明
itemStatus開始したのステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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.StartStateMachineByStampSheet( &state_machine.StartStateMachineByStampSheetRequest { StampSheet: pointy.String("stampSheet"), KeyId: pointy.String("key-0001"), } ) if err != nil { panic("error occurred") } item := result.Item
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\StartStateMachineByStampSheetRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->startStateMachineByStampSheet( (new StartStateMachineByStampSheetRequest()) ->withStampSheet("stampSheet") ->withKeyId("key-0001") ); $item = $result->getItem(); } catch (Gs2Exception $e) { exit("error occurred") }
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.StartStateMachineByStampSheetRequest; import io.gs2.stateMachine.result.StartStateMachineByStampSheetResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2StateMachineRestClient client = new Gs2StateMachineRestClient(session); try { StartStateMachineByStampSheetResult result = client.startStateMachineByStampSheet( new StartStateMachineByStampSheetRequest() .withStampSheet("stampSheet") .withKeyId("key-0001") ); Status item = result.getItem(); } catch (Gs2Exception e) { System.exit(1); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.StartStateMachineByStampSheetRequest; using Gs2.Gs2StateMachine.Result.StartStateMachineByStampSheetResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.StartStateMachineByStampSheetResult> asyncResult = null; yield return client.StartStateMachineByStampSheet( new Gs2.Gs2StateMachine.Request.StartStateMachineByStampSheetRequest() .WithStampSheet("stampSheet") .WithKeyId("key-0001"), r => asyncResult = r ); if (asyncResult.Error != null) { throw asyncResult.Error; } var result = asyncResult.Result; var item = result.Item;
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.startStateMachineByStampSheet( new Gs2StateMachine.StartStateMachineByStampSheetRequest() .withStampSheet("stampSheet") .withKeyId("key-0001") ); const item = result.getItem(); } catch (e) { process.exit(1); }
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_stamp_sheet( state_machine.StartStateMachineByStampSheetRequest() .with_stamp_sheet('stampSheet') .with_key_id('key-0001') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('state_machine') api_result = client.start_state_machine_by_stamp_sheet({ stampSheet="stampSheet", keyId="key-0001", }) if(api_result.isError) then -- When error occurs fail(api_result['statusCode'], api_result['message']) end result = api_result.result item = result.item;
client = gs2('state_machine') api_result_handler = client.start_state_machine_by_stamp_sheet_async({ stampSheet="stampSheet", keyId="key-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['message']) end result = api_result.result item = result.item;

emit

ステートマシンにメッセージを送信

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
accessTokenstring~ 128文字アクセストークン
statusNamestring~ 36文字ステータス名
eventNamestring~ 36文字イベントの名前
argsstring“{}”~ 4096文字ステートマシンに渡す引数

Result

説明
itemStatusステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.EmitRequest; using Gs2.Gs2StateMachine.Result.EmitResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.EmitResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

emitByUserId

ユーザIDを指定してステートマシンにメッセージを送信

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
userIdstring~ 128文字ユーザーID
statusNamestring~ 36文字ステータス名
eventNamestring~ 36文字イベントの名前
argsstring“{}”~ 4096文字ステートマシンに渡す引数
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemStatusステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.EmitByUserIdRequest; using Gs2.Gs2StateMachine.Result.EmitByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.EmitByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

report

ステートマシンにメッセージを送信

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
accessTokenstring~ 128文字アクセストークン
statusNamestring~ 36文字ステータス名
eventsList<Event>~ 1000 itemsイベントのリスト

Result

説明
itemStatusステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.ReportRequest; using Gs2.Gs2StateMachine.Result.ReportResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.ReportResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

reportByUserId

ユーザIDを指定してステートマシンにメッセージを送信

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
userIdstring~ 128文字ユーザーID
statusNamestring~ 36文字ステータス名
eventsList<Event>~ 1000 itemsイベントのリスト
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemStatusステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.ReportByUserIdRequest; using Gs2.Gs2StateMachine.Result.ReportByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.ReportByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

deleteStatusByUserId

ユーザIDを指定してステートマシンを削除

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
userIdstring~ 128文字ユーザーID
statusNamestring~ 36文字ステータス名
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemStatus削除したステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.DeleteStatusByUserIdRequest; using Gs2.Gs2StateMachine.Result.DeleteStatusByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.DeleteStatusByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

exitStateMachine

ステートマシンを終了して削除

ステートマシンの状態が「Pass」または「Error」の時にのみ使用できます。

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
accessTokenstring~ 128文字アクセストークン
statusNamestring~ 36文字ステータス名

Result

説明
itemStatus終了したステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.ExitStateMachineRequest; using Gs2.Gs2StateMachine.Result.ExitStateMachineResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.ExitStateMachineResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;

exitStateMachineByUserId

ユーザIDを指定してステートマシンを終了して削除

ステートマシンの状態が「Pass」または「Error」の時にのみ使用できます。

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
userIdstring~ 128文字ユーザーID
statusNamestring~ 36文字ステータス名
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemStatus終了したステートマシンの状態

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/state_machine" 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
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 Gs2AccountRestClient( $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") }
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); }
using Gs2.Core.Model.Region; using Gs2.Core.Model.BasicGs2Credential; using Gs2.Core.Net.Gs2RestSession; using Gs2.Core.Exception.Gs2Exception; using Gs2.Core.AsyncResult; using Gs2.Gs2StateMachine.Gs2StateMachineRestClient; using Gs2.Gs2StateMachine.Request.ExitStateMachineByUserIdRequest; using Gs2.Gs2StateMachine.Result.ExitStateMachineByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2StateMachineRestClient(session); AsyncResult<Gs2.Gs2StateMachine.Result.ExitStateMachineByUserIdResult> 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;
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); }
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)
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['message']) end result = api_result.result item = result.item;
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['message']) end result = api_result.result item = result.item;