GS2-Limit SDK API リファレンス

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

モデル

Namespace

ネームスペース

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

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

有効化条件必須デフォルト値の制限説明
namespaceIdstring~ 1024文字ネームスペースGRN
namestring~ 128文字ネームスペース名
descriptionstring~ 1024文字説明文
logSettingLogSettingログの出力設定
createdAtlong現在時刻作成日時 (UNIX時間 単位:ミリ秒)
updatedAtlong現在時刻最終更新日時 (UNIX時間 単位:ミリ秒)
revisionlong0~ 9223372036854775805リビジョン

Counter

回数制限の現在の値

有効化条件必須デフォルト値の制限説明
counterIdstring~ 1024文字カウンターGRN
limitNamestring~ 128文字回数制限モデルの名前
namestring~ 128文字カウンターの名前
userIdstring~ 128文字ユーザーID
countint0~ 2147483646カウント値
nextResetAtlong次回リセットタイミング (UNIX時間 単位:ミリ秒)
createdAtlong現在時刻作成日時 (UNIX時間 単位:ミリ秒)
updatedAtlong現在時刻最終更新日時 (UNIX時間 単位:ミリ秒)
revisionlong0~ 9223372036854775805リビジョン

LimitModelMaster

回数制限マスター

回数制限にはリセット間隔を設定できます。
リセット間隔は 毎日・毎週・毎月・リセットしない の4種類から選択ができます。
全ての時間は協定世界時(UTC)で指定します。

回数制限の最大値はマスターデータでは設定しません。
なぜなら、ステップアップガチャのような仕組みで、購入回数カウンターが 3 回未満の場合に購入できる商品。
前述の商品を購入することが出来ず、購入回数カウンターが 5 回未満の場合に購入できる商品。というようにコンテキストによって最大値を変更できるようにするためです。

ここで定義した回数制限設定に紐づくカウンターは複数作成できます。
例えば、1回しか受け取れないクエスト報酬があるときに、クエストごとに回数制限を用意するのではなく
1つの回数制限を用意し、クエスト毎のカウンターを用意することで、設定の数を爆発させないことができます。

有効化条件必須デフォルト値の制限説明
limitModelIdstring~ 1024文字回数制限モデルマスターGRN
namestring~ 128文字回数制限モデル名
descriptionstring~ 1024文字説明文
metadatastring~ 2048文字メタデータ
resetTypeenum {
    “notReset”,
    “daily”,
    “weekly”,
    “monthly”,
    “days”
}
~ 128文字リセットタイミング
resetDayOfMonthint{resetType} == “monthly”1 ~ 31リセットをする日にち(月の日数を超える場合は、最終日として扱われます)
resetDayOfWeekenum {
    “sunday”,
    “monday”,
    “tuesday”,
    “wednesday”,
    “thursday”,
    “friday”,
    “saturday”
}
{resetType} == “weekly”~ 128文字リセットする曜日
resetHourint{resetType} in [“monthly”, “weekly”, “daily”]~ 23リセット時刻
anchorTimestamplong{resetType} == “days”経過日数のカウントをする基準日 (UNIX時間 単位:ミリ秒)
daysint{resetType} == “days”1 ~ 2147483646リセットする日数
createdAtlong現在時刻作成日時 (UNIX時間 単位:ミリ秒)
updatedAtlong現在時刻最終更新日時 (UNIX時間 単位:ミリ秒)
revisionlong0~ 9223372036854775805リビジョン

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

定義説明
notResetリセットしない
daily毎日
weekly毎週
monthly毎月
days一定日数

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

定義説明
sunday日曜日
monday月曜日
tuesday火曜日
wednesday水曜日
thursday木曜日
friday金曜日
saturday土曜日

CurrentLimitMaster

現在有効なマスターデータ

GS2ではマスターデータの管理にJSON形式のファイルを使用します。
ファイルをアップロードすることで、実際にサーバーに設定を反映することができます。

JSONファイルを作成する方法として、マネージメントコンソール上でのマスターデータエディタを提供していますが
よりゲームの運営に相応しいツールを作成し、適切なフォーマットのJSONファイルを書き出すことでもサービスを利用可能です。

有効化条件必須デフォルト値の制限説明
namespaceIdstring~ 1024文字現在有効な回数制限設定GRN
settingsstring~ 5242880文字マスターデータ

GitHubCheckoutSetting

GitHubからマスターデータをチェックアウトする設定

有効化条件必須デフォルト値の制限説明
apiKeyIdstring~ 1024文字GitHub のAPIキーGRN
repositoryNamestring~ 1024文字リポジトリ名
sourcePathstring~ 1024文字ソースコードのファイルパス
referenceTypeenum {
    “commit_hash”,
    “branch”,
    “tag”
}
~ 128文字コードの取得元
commitHashstring{referenceType} == “commit_hash”~ 1024文字コミットハッシュ
branchNamestring{referenceType} == “branch”~ 1024文字ブランチ名
tagNamestring{referenceType} == “tag”~ 1024文字タグ名

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

定義説明
commit_hashコミットハッシュ
branchブランチ
tagタグ

LogSetting

ログの書き出し設定

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

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

LimitModel

回数制限モデル

回数制限にはリセット間隔を設定できます。
リセット間隔は 毎日・毎週・毎月・リセットしない の4種類から選択ができます。

回数制限の最大値はマスターデータでは設定しません。
なぜなら、ステップアップガチャのような仕組みで、購入回数カウンターが 3 回未満の場合に購入できる商品。
前述の商品を購入することが出来ず、購入回数カウンターが 5 回未満の場合に購入できる商品。というようにコンテキストによって最大値を変更できるようにするためです。

有効化条件必須デフォルト値の制限説明
limitModelIdstring~ 1024文字回数制限モデルGRN
namestring~ 128文字回数制限モデル名
metadatastring~ 2048文字メタデータ
resetTypeenum {
    “notReset”,
    “daily”,
    “weekly”,
    “monthly”,
    “days”
}
~ 128文字リセットタイミング
resetDayOfMonthint{resetType} == “monthly”1 ~ 31リセットをする日にち(月の日数を超える場合は、最終日として扱われます)
resetDayOfWeekenum {
    “sunday”,
    “monday”,
    “tuesday”,
    “wednesday”,
    “thursday”,
    “friday”,
    “saturday”
}
{resetType} == “weekly”~ 128文字リセットする曜日
resetHourint{resetType} in [“monthly”, “weekly”, “daily”]~ 23リセット時刻
anchorTimestamplong{resetType} == “days”経過日数のカウントをする基準日 (UNIX時間 単位:ミリ秒)
daysint{resetType} == “days”1 ~ 2147483646リセットする日数

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

定義説明
notResetリセットしない
daily毎日
weekly毎週
monthly毎月
days一定日数

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

定義説明
sunday日曜日
monday月曜日
tuesday火曜日
wednesday水曜日
thursday木曜日
friday金曜日
saturday土曜日

メソッド

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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.DescribeNamespaces( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.DescribeNamespacesRequest; import io.gs2.limit.result.DescribeNamespacesResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.DescribeNamespacesRequest; using Gs2.Gs2Limit.Result.DescribeNamespacesResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.DescribeNamespacesResult> asyncResult = null; yield return client.DescribeNamespaces( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.describeNamespaces( new Gs2Limit.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 limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.describe_namespaces( limit.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('limit') 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('limit') 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文字説明文
logSettingLogSettingログの出力設定

Result

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

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CreateNamespace( &limit.CreateNamespaceRequest { Name: pointy.String("namespace-0001"), Description: nil, LogSetting: &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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) ->withLogSetting((new \Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CreateNamespaceRequest; import io.gs2.limit.result.CreateNamespaceResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { CreateNamespaceResult result = client.createNamespace( new CreateNamespaceRequest() .withName("namespace-0001") .withDescription(null) .withLogSetting(new io.gs2.limit.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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CreateNamespaceRequest; using Gs2.Gs2Limit.Result.CreateNamespaceResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CreateNamespaceResult> asyncResult = null; yield return client.CreateNamespace( new Gs2.Gs2Limit.Request.CreateNamespaceRequest() .WithName("namespace-0001") .WithDescription(null) .WithLogSetting(new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.createNamespace( new Gs2Limit.CreateNamespaceRequest() .withName("namespace-0001") .withDescription(null) .withLogSetting(new Gs2Limit.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 limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.create_namespace( limit.CreateNamespaceRequest() .with_name('namespace-0001') .with_description(None) .with_log_setting( limit.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('limit') api_result = client.create_namespace({ name="namespace-0001", description=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('limit') api_result_handler = client.create_namespace_async({ name="namespace-0001", description=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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.GetNamespaceStatus( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.GetNamespaceStatusRequest; import io.gs2.limit.result.GetNamespaceStatusResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.GetNamespaceStatusRequest; using Gs2.Gs2Limit.Result.GetNamespaceStatusResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.GetNamespaceStatusResult> asyncResult = null; yield return client.GetNamespaceStatus( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.getNamespaceStatus( new Gs2Limit.GetNamespaceStatusRequest() .withNamespaceName("namespace-0001") ); const status = result.getStatus(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.get_namespace_status( limit.GetNamespaceStatusRequest() .with_namespace_name('namespace-0001') ) status = result.status except core.Gs2Exception as e: exit(1)
client = gs2('limit') 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('limit') 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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.GetNamespace( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.GetNamespaceRequest; import io.gs2.limit.result.GetNamespaceResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.GetNamespaceRequest; using Gs2.Gs2Limit.Result.GetNamespaceResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.GetNamespaceResult> asyncResult = null; yield return client.GetNamespace( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.getNamespace( new Gs2Limit.GetNamespaceRequest() .withNamespaceName("namespace-0001") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.get_namespace( limit.GetNamespaceRequest() .with_namespace_name('namespace-0001') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') 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('limit') 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文字説明文
logSettingLogSettingログの出力設定

Result

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

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.UpdateNamespace( &limit.UpdateNamespaceRequest { NamespaceName: pointy.String("namespace-0001"), Description: pointy.String("description1"), LogSetting: &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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") ->withLogSetting((new \Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.UpdateNamespaceRequest; import io.gs2.limit.result.UpdateNamespaceResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { UpdateNamespaceResult result = client.updateNamespace( new UpdateNamespaceRequest() .withNamespaceName("namespace-0001") .withDescription("description1") .withLogSetting(new io.gs2.limit.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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.UpdateNamespaceRequest; using Gs2.Gs2Limit.Result.UpdateNamespaceResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.UpdateNamespaceResult> asyncResult = null; yield return client.UpdateNamespace( new Gs2.Gs2Limit.Request.UpdateNamespaceRequest() .WithNamespaceName("namespace-0001") .WithDescription("description1") .WithLogSetting(new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.updateNamespace( new Gs2Limit.UpdateNamespaceRequest() .withNamespaceName("namespace-0001") .withDescription("description1") .withLogSetting(new Gs2Limit.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 limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.update_namespace( limit.UpdateNamespaceRequest() .with_namespace_name('namespace-0001') .with_description('description1') .with_log_setting( limit.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('limit') api_result = client.update_namespace({ namespaceName="namespace-0001", description="description1", 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('limit') api_result_handler = client.update_namespace_async({ namespaceName="namespace-0001", description="description1", 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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.DeleteNamespace( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.DeleteNamespaceRequest; import io.gs2.limit.result.DeleteNamespaceResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.DeleteNamespaceRequest; using Gs2.Gs2Limit.Result.DeleteNamespaceResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.DeleteNamespaceResult> asyncResult = null; yield return client.DeleteNamespace( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.deleteNamespace( new Gs2Limit.DeleteNamespaceRequest() .withNamespaceName("namespace-0001") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.delete_namespace( limit.DeleteNamespaceRequest() .with_namespace_name('namespace-0001') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') 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('limit') 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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.DumpUserDataByUserId( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.DumpUserDataByUserIdRequest; import io.gs2.limit.result.DumpUserDataByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.DumpUserDataByUserIdRequest; using Gs2.Gs2Limit.Result.DumpUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.DumpUserDataByUserIdResult> asyncResult = null; yield return client.DumpUserDataByUserId( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.dumpUserDataByUserId( new Gs2Limit.DumpUserDataByUserIdRequest() .withUserId("user-0001") .withTimeOffsetToken(null) ); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.dump_user_data_by_user_id( limit.DumpUserDataByUserIdRequest() .with_user_id('user-0001') .with_time_offset_token(None) ) except core.Gs2Exception as e: exit(1)
client = gs2('limit') 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('limit') 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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CheckDumpUserDataByUserId( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CheckDumpUserDataByUserIdRequest; import io.gs2.limit.result.CheckDumpUserDataByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CheckDumpUserDataByUserIdRequest; using Gs2.Gs2Limit.Result.CheckDumpUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CheckDumpUserDataByUserIdResult> asyncResult = null; yield return client.CheckDumpUserDataByUserId( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.checkDumpUserDataByUserId( new Gs2Limit.CheckDumpUserDataByUserIdRequest() .withUserId("user-0001") .withTimeOffsetToken(null) ); const url = result.getUrl(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.check_dump_user_data_by_user_id( limit.CheckDumpUserDataByUserIdRequest() .with_user_id('user-0001') .with_time_offset_token(None) ) url = result.url except core.Gs2Exception as e: exit(1)
client = gs2('limit') 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('limit') 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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CleanUserDataByUserId( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CleanUserDataByUserIdRequest; import io.gs2.limit.result.CleanUserDataByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CleanUserDataByUserIdRequest; using Gs2.Gs2Limit.Result.CleanUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CleanUserDataByUserIdResult> asyncResult = null; yield return client.CleanUserDataByUserId( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.cleanUserDataByUserId( new Gs2Limit.CleanUserDataByUserIdRequest() .withUserId("user-0001") .withTimeOffsetToken(null) ); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.clean_user_data_by_user_id( limit.CleanUserDataByUserIdRequest() .with_user_id('user-0001') .with_time_offset_token(None) ) except core.Gs2Exception as e: exit(1)
client = gs2('limit') 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('limit') 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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CheckCleanUserDataByUserId( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CheckCleanUserDataByUserIdRequest; import io.gs2.limit.result.CheckCleanUserDataByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CheckCleanUserDataByUserIdRequest; using Gs2.Gs2Limit.Result.CheckCleanUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CheckCleanUserDataByUserIdResult> asyncResult = null; yield return client.CheckCleanUserDataByUserId( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.checkCleanUserDataByUserId( new Gs2Limit.CheckCleanUserDataByUserIdRequest() .withUserId("user-0001") .withTimeOffsetToken(null) ); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.check_clean_user_data_by_user_id( limit.CheckCleanUserDataByUserIdRequest() .with_user_id('user-0001') .with_time_offset_token(None) ) except core.Gs2Exception as e: exit(1)
client = gs2('limit') 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('limit') 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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.PrepareImportUserDataByUserId( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.PrepareImportUserDataByUserIdRequest; import io.gs2.limit.result.PrepareImportUserDataByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.PrepareImportUserDataByUserIdRequest; using Gs2.Gs2Limit.Result.PrepareImportUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.PrepareImportUserDataByUserIdResult> asyncResult = null; yield return client.PrepareImportUserDataByUserId( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.prepareImportUserDataByUserId( new Gs2Limit.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 limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.prepare_import_user_data_by_user_id( limit.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('limit') 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('limit') 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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.ImportUserDataByUserId( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.ImportUserDataByUserIdRequest; import io.gs2.limit.result.ImportUserDataByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.ImportUserDataByUserIdRequest; using Gs2.Gs2Limit.Result.ImportUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.ImportUserDataByUserIdResult> asyncResult = null; yield return client.ImportUserDataByUserId( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.importUserDataByUserId( new Gs2Limit.ImportUserDataByUserIdRequest() .withUserId("user-0001") .withUploadToken("upload-0001") .withTimeOffsetToken(null) ); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.import_user_data_by_user_id( limit.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('limit') 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('limit') 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/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CheckImportUserDataByUserId( &limit.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\Limit\Gs2LimitRestClient; use Gs2\Limit\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CheckImportUserDataByUserIdRequest; import io.gs2.limit.result.CheckImportUserDataByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CheckImportUserDataByUserIdRequest; using Gs2.Gs2Limit.Result.CheckImportUserDataByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CheckImportUserDataByUserIdResult> asyncResult = null; yield return client.CheckImportUserDataByUserId( new Gs2.Gs2Limit.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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.checkImportUserDataByUserId( new Gs2Limit.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 limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.check_import_user_data_by_user_id( limit.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('limit') 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('limit') 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;

describeCounters

カウンターの一覧を取得

Request

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

Result

説明
itemsList<Counter>カウンターのリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.DescribeCounters( &limit.DescribeCountersRequest { NamespaceName: pointy.String("namespace-0001"), AccessToken: pointy.String("accessToken-0001"), LimitName: pointy.String("daily"), 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\DescribeCountersRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->describeCounters( (new DescribeCountersRequest()) ->withNamespaceName("namespace-0001") ->withAccessToken("accessToken-0001") ->withLimitName("daily") ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.DescribeCountersRequest; import io.gs2.limit.result.DescribeCountersResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { DescribeCountersResult result = client.describeCounters( new DescribeCountersRequest() .withNamespaceName("namespace-0001") .withAccessToken("accessToken-0001") .withLimitName("daily") .withPageToken(null) .withLimit(null) ); List<Counter> 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.DescribeCountersRequest; using Gs2.Gs2Limit.Result.DescribeCountersResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.DescribeCountersResult> asyncResult = null; yield return client.DescribeCounters( new Gs2.Gs2Limit.Request.DescribeCountersRequest() .WithNamespaceName("namespace-0001") .WithAccessToken("accessToken-0001") .WithLimitName("daily") .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.describeCounters( new Gs2Limit.DescribeCountersRequest() .withNamespaceName("namespace-0001") .withAccessToken("accessToken-0001") .withLimitName("daily") .withPageToken(null) .withLimit(null) ); const items = result.getItems(); const nextPageToken = result.getNextPageToken(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.describe_counters( limit.DescribeCountersRequest() .with_namespace_name('namespace-0001') .with_access_token('accessToken-0001') .with_limit_name('daily') .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('limit') api_result = client.describe_counters({ namespaceName="namespace-0001", accessToken="accessToken-0001", limitName="daily", 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('limit') api_result_handler = client.describe_counters_async({ namespaceName="namespace-0001", accessToken="accessToken-0001", limitName="daily", 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;

describeCountersByUserId

ユーザーIDを指定してカウンターの一覧を取得

Request

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

Result

説明
itemsList<Counter>カウンターのリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.DescribeCountersByUserId( &limit.DescribeCountersByUserIdRequest { NamespaceName: pointy.String("namespace-0001"), UserId: pointy.String("user-0001"), LimitName: pointy.String("daily"), 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\DescribeCountersByUserIdRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->describeCountersByUserId( (new DescribeCountersByUserIdRequest()) ->withNamespaceName("namespace-0001") ->withUserId("user-0001") ->withLimitName("daily") ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.DescribeCountersByUserIdRequest; import io.gs2.limit.result.DescribeCountersByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { DescribeCountersByUserIdResult result = client.describeCountersByUserId( new DescribeCountersByUserIdRequest() .withNamespaceName("namespace-0001") .withUserId("user-0001") .withLimitName("daily") .withPageToken(null) .withLimit(null) .withTimeOffsetToken(null) ); List<Counter> 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.DescribeCountersByUserIdRequest; using Gs2.Gs2Limit.Result.DescribeCountersByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.DescribeCountersByUserIdResult> asyncResult = null; yield return client.DescribeCountersByUserId( new Gs2.Gs2Limit.Request.DescribeCountersByUserIdRequest() .WithNamespaceName("namespace-0001") .WithUserId("user-0001") .WithLimitName("daily") .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.describeCountersByUserId( new Gs2Limit.DescribeCountersByUserIdRequest() .withNamespaceName("namespace-0001") .withUserId("user-0001") .withLimitName("daily") .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 limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.describe_counters_by_user_id( limit.DescribeCountersByUserIdRequest() .with_namespace_name('namespace-0001') .with_user_id('user-0001') .with_limit_name('daily') .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('limit') api_result = client.describe_counters_by_user_id({ namespaceName="namespace-0001", userId="user-0001", limitName="daily", 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('limit') api_result_handler = client.describe_counters_by_user_id_async({ namespaceName="namespace-0001", userId="user-0001", limitName="daily", 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;

getCounter

カウンターを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
limitNamestring~ 128文字回数制限モデルの名前
accessTokenstring~ 128文字アクセストークン
counterNamestring~ 128文字カウンターの名前

Result

説明
itemCounterカウンター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.GetCounter( &limit.GetCounterRequest { NamespaceName: pointy.String("namespace-0001"), LimitName: pointy.String("daily"), AccessToken: pointy.String("accessToken-0001"), CounterName: pointy.String("counter1"), } ) 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\GetCounterRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->getCounter( (new GetCounterRequest()) ->withNamespaceName("namespace-0001") ->withLimitName("daily") ->withAccessToken("accessToken-0001") ->withCounterName("counter1") ); $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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.GetCounterRequest; import io.gs2.limit.result.GetCounterResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { GetCounterResult result = client.getCounter( new GetCounterRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withAccessToken("accessToken-0001") .withCounterName("counter1") ); Counter 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.GetCounterRequest; using Gs2.Gs2Limit.Result.GetCounterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.GetCounterResult> asyncResult = null; yield return client.GetCounter( new Gs2.Gs2Limit.Request.GetCounterRequest() .WithNamespaceName("namespace-0001") .WithLimitName("daily") .WithAccessToken("accessToken-0001") .WithCounterName("counter1"), 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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.getCounter( new Gs2Limit.GetCounterRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withAccessToken("accessToken-0001") .withCounterName("counter1") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.get_counter( limit.GetCounterRequest() .with_namespace_name('namespace-0001') .with_limit_name('daily') .with_access_token('accessToken-0001') .with_counter_name('counter1') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.get_counter({ namespaceName="namespace-0001", limitName="daily", accessToken="accessToken-0001", counterName="counter1", }) 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('limit') api_result_handler = client.get_counter_async({ namespaceName="namespace-0001", limitName="daily", accessToken="accessToken-0001", counterName="counter1", }) 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;

getCounterByUserId

ユーザIDを指定してカウンターを取得

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
limitNamestring~ 128文字回数制限モデルの名前
userIdstring~ 128文字ユーザーID
counterNamestring~ 128文字カウンターの名前
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemCounterカウンター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.GetCounterByUserId( &limit.GetCounterByUserIdRequest { NamespaceName: pointy.String("namespace-0001"), LimitName: pointy.String("daily"), UserId: pointy.String("user-0001"), CounterName: pointy.String("counter2"), 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\GetCounterByUserIdRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->getCounterByUserId( (new GetCounterByUserIdRequest()) ->withNamespaceName("namespace-0001") ->withLimitName("daily") ->withUserId("user-0001") ->withCounterName("counter2") ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.GetCounterByUserIdRequest; import io.gs2.limit.result.GetCounterByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { GetCounterByUserIdResult result = client.getCounterByUserId( new GetCounterByUserIdRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withUserId("user-0001") .withCounterName("counter2") .withTimeOffsetToken(null) ); Counter 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.GetCounterByUserIdRequest; using Gs2.Gs2Limit.Result.GetCounterByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.GetCounterByUserIdResult> asyncResult = null; yield return client.GetCounterByUserId( new Gs2.Gs2Limit.Request.GetCounterByUserIdRequest() .WithNamespaceName("namespace-0001") .WithLimitName("daily") .WithUserId("user-0001") .WithCounterName("counter2") .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.getCounterByUserId( new Gs2Limit.GetCounterByUserIdRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withUserId("user-0001") .withCounterName("counter2") .withTimeOffsetToken(null) ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.get_counter_by_user_id( limit.GetCounterByUserIdRequest() .with_namespace_name('namespace-0001') .with_limit_name('daily') .with_user_id('user-0001') .with_counter_name('counter2') .with_time_offset_token(None) ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.get_counter_by_user_id({ namespaceName="namespace-0001", limitName="daily", userId="user-0001", counterName="counter2", 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('limit') api_result_handler = client.get_counter_by_user_id_async({ namespaceName="namespace-0001", limitName="daily", userId="user-0001", counterName="counter2", 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;

countUp

カウントアップ

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
limitNamestring~ 128文字回数制限モデルの名前
counterNamestring~ 128文字カウンターの名前
accessTokenstring~ 128文字アクセストークン
countUpValueint11 ~ 2147483646カウントアップする量
maxValueint1 ~ 2147483646カウントアップを許容する最大値

Result

説明
itemCounterカウントを増やしたカウンター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CountUp( &limit.CountUpRequest { NamespaceName: pointy.String("namespace-0001"), LimitName: pointy.String("daily"), CounterName: pointy.String("counter1"), AccessToken: pointy.String("accessToken-0001"), CountUpValue: pointy.Int32(1), MaxValue: pointy.Int32(100), } ) 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\CountUpRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->countUp( (new CountUpRequest()) ->withNamespaceName("namespace-0001") ->withLimitName("daily") ->withCounterName("counter1") ->withAccessToken("accessToken-0001") ->withCountUpValue(1) ->withMaxValue(100) ); $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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CountUpRequest; import io.gs2.limit.result.CountUpResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { CountUpResult result = client.countUp( new CountUpRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withCounterName("counter1") .withAccessToken("accessToken-0001") .withCountUpValue(1) .withMaxValue(100) ); Counter 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CountUpRequest; using Gs2.Gs2Limit.Result.CountUpResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CountUpResult> asyncResult = null; yield return client.CountUp( new Gs2.Gs2Limit.Request.CountUpRequest() .WithNamespaceName("namespace-0001") .WithLimitName("daily") .WithCounterName("counter1") .WithAccessToken("accessToken-0001") .WithCountUpValue(1) .WithMaxValue(100), 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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.countUp( new Gs2Limit.CountUpRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withCounterName("counter1") .withAccessToken("accessToken-0001") .withCountUpValue(1) .withMaxValue(100) ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.count_up( limit.CountUpRequest() .with_namespace_name('namespace-0001') .with_limit_name('daily') .with_counter_name('counter1') .with_access_token('accessToken-0001') .with_count_up_value(1) .with_max_value(100) ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.count_up({ namespaceName="namespace-0001", limitName="daily", counterName="counter1", accessToken="accessToken-0001", countUpValue=1, maxValue=100, }) 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('limit') api_result_handler = client.count_up_async({ namespaceName="namespace-0001", limitName="daily", counterName="counter1", accessToken="accessToken-0001", countUpValue=1, maxValue=100, }) 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;

countUpByUserId

ユーザIDを指定してカウントアップ

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
limitNamestring~ 128文字回数制限モデルの名前
counterNamestring~ 128文字カウンターの名前
userIdstring~ 128文字ユーザーID
countUpValueint11 ~ 2147483646カウントアップする量
maxValueint1 ~ 2147483646カウントアップを許容する最大値
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemCounterカウントを増やしたカウンター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CountUpByUserId( &limit.CountUpByUserIdRequest { NamespaceName: pointy.String("namespace-0001"), LimitName: pointy.String("daily"), CounterName: pointy.String("counter2"), UserId: pointy.String("user-0001"), CountUpValue: pointy.Int32(2), MaxValue: pointy.Int32(100), 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\CountUpByUserIdRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->countUpByUserId( (new CountUpByUserIdRequest()) ->withNamespaceName("namespace-0001") ->withLimitName("daily") ->withCounterName("counter2") ->withUserId("user-0001") ->withCountUpValue(2) ->withMaxValue(100) ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CountUpByUserIdRequest; import io.gs2.limit.result.CountUpByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { CountUpByUserIdResult result = client.countUpByUserId( new CountUpByUserIdRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withCounterName("counter2") .withUserId("user-0001") .withCountUpValue(2) .withMaxValue(100) .withTimeOffsetToken(null) ); Counter 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CountUpByUserIdRequest; using Gs2.Gs2Limit.Result.CountUpByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CountUpByUserIdResult> asyncResult = null; yield return client.CountUpByUserId( new Gs2.Gs2Limit.Request.CountUpByUserIdRequest() .WithNamespaceName("namespace-0001") .WithLimitName("daily") .WithCounterName("counter2") .WithUserId("user-0001") .WithCountUpValue(2) .WithMaxValue(100) .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.countUpByUserId( new Gs2Limit.CountUpByUserIdRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withCounterName("counter2") .withUserId("user-0001") .withCountUpValue(2) .withMaxValue(100) .withTimeOffsetToken(null) ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.count_up_by_user_id( limit.CountUpByUserIdRequest() .with_namespace_name('namespace-0001') .with_limit_name('daily') .with_counter_name('counter2') .with_user_id('user-0001') .with_count_up_value(2) .with_max_value(100) .with_time_offset_token(None) ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.count_up_by_user_id({ namespaceName="namespace-0001", limitName="daily", counterName="counter2", userId="user-0001", countUpValue=2, maxValue=100, 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('limit') api_result_handler = client.count_up_by_user_id_async({ namespaceName="namespace-0001", limitName="daily", counterName="counter2", userId="user-0001", countUpValue=2, maxValue=100, 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;

countDownByUserId

ユーザIDを指定してカウントダウン

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
limitNamestring~ 128文字回数制限モデルの名前
counterNamestring~ 128文字カウンターの名前
userIdstring~ 128文字ユーザーID
countDownValueint11 ~ 2147483646カウントダウンする量
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemCounterカウントを増やしたカウンター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CountDownByUserId( &limit.CountDownByUserIdRequest { NamespaceName: pointy.String("namespace-0001"), LimitName: pointy.String("daily"), CounterName: pointy.String("counter2"), UserId: pointy.String("user-0001"), CountDownValue: pointy.Int32(2), 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\CountDownByUserIdRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->countDownByUserId( (new CountDownByUserIdRequest()) ->withNamespaceName("namespace-0001") ->withLimitName("daily") ->withCounterName("counter2") ->withUserId("user-0001") ->withCountDownValue(2) ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CountDownByUserIdRequest; import io.gs2.limit.result.CountDownByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { CountDownByUserIdResult result = client.countDownByUserId( new CountDownByUserIdRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withCounterName("counter2") .withUserId("user-0001") .withCountDownValue(2) .withTimeOffsetToken(null) ); Counter 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CountDownByUserIdRequest; using Gs2.Gs2Limit.Result.CountDownByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CountDownByUserIdResult> asyncResult = null; yield return client.CountDownByUserId( new Gs2.Gs2Limit.Request.CountDownByUserIdRequest() .WithNamespaceName("namespace-0001") .WithLimitName("daily") .WithCounterName("counter2") .WithUserId("user-0001") .WithCountDownValue(2) .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.countDownByUserId( new Gs2Limit.CountDownByUserIdRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withCounterName("counter2") .withUserId("user-0001") .withCountDownValue(2) .withTimeOffsetToken(null) ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.count_down_by_user_id( limit.CountDownByUserIdRequest() .with_namespace_name('namespace-0001') .with_limit_name('daily') .with_counter_name('counter2') .with_user_id('user-0001') .with_count_down_value(2) .with_time_offset_token(None) ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.count_down_by_user_id({ namespaceName="namespace-0001", limitName="daily", counterName="counter2", userId="user-0001", countDownValue=2, 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('limit') api_result_handler = client.count_down_by_user_id_async({ namespaceName="namespace-0001", limitName="daily", counterName="counter2", userId="user-0001", countDownValue=2, 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;

deleteCounterByUserId

ユーザIDを指定してカウンターを削除

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
limitNamestring~ 128文字回数制限モデルの名前
userIdstring~ 128文字ユーザーID
counterNamestring~ 128文字カウンターの名前
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

Result

説明
itemCounter削除したカウンター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.DeleteCounterByUserId( &limit.DeleteCounterByUserIdRequest { NamespaceName: pointy.String("namespace-0001"), LimitName: pointy.String("daily"), UserId: pointy.String("user-0001"), CounterName: pointy.String("counter1"), 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\DeleteCounterByUserIdRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->deleteCounterByUserId( (new DeleteCounterByUserIdRequest()) ->withNamespaceName("namespace-0001") ->withLimitName("daily") ->withUserId("user-0001") ->withCounterName("counter1") ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.DeleteCounterByUserIdRequest; import io.gs2.limit.result.DeleteCounterByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { DeleteCounterByUserIdResult result = client.deleteCounterByUserId( new DeleteCounterByUserIdRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withUserId("user-0001") .withCounterName("counter1") .withTimeOffsetToken(null) ); Counter 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.DeleteCounterByUserIdRequest; using Gs2.Gs2Limit.Result.DeleteCounterByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.DeleteCounterByUserIdResult> asyncResult = null; yield return client.DeleteCounterByUserId( new Gs2.Gs2Limit.Request.DeleteCounterByUserIdRequest() .WithNamespaceName("namespace-0001") .WithLimitName("daily") .WithUserId("user-0001") .WithCounterName("counter1") .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.deleteCounterByUserId( new Gs2Limit.DeleteCounterByUserIdRequest() .withNamespaceName("namespace-0001") .withLimitName("daily") .withUserId("user-0001") .withCounterName("counter1") .withTimeOffsetToken(null) ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.delete_counter_by_user_id( limit.DeleteCounterByUserIdRequest() .with_namespace_name('namespace-0001') .with_limit_name('daily') .with_user_id('user-0001') .with_counter_name('counter1') .with_time_offset_token(None) ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.delete_counter_by_user_id({ namespaceName="namespace-0001", limitName="daily", userId="user-0001", counterName="counter1", 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('limit') api_result_handler = client.delete_counter_by_user_id_async({ namespaceName="namespace-0001", limitName="daily", userId="user-0001", counterName="counter1", 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;

verifyCounter

カウンター値を検証

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
accessTokenstring~ 128文字アクセストークン
limitNamestring~ 128文字回数制限モデルの名前
counterNamestring~ 128文字カウンターの名前
verifyTypeenum {
    “less”,
    “lessEqual”,
    “greater”,
    “greaterEqual”,
    “equal”,
    “notEqual”
}
~ 128文字検証の種類
countint0~ 2147483646カウント値
multiplyValueSpecifyingQuantitybooltrue数量指定した際に、検証に使用する値も乗算するか

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

定義説明
lessカウンター値が指定値未満であること
lessEqualカウンター値が指定値以下であること
greaterカウンター値が指定値超過であること
greaterEqualカウンター値が指定値以上であること
equalカウンター値が指定値と一致すること
notEqualカウンター値が指定値と一致しないこと

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.VerifyCounter( &limit.VerifyCounterRequest { NamespaceName: pointy.String("namespace-0001"), AccessToken: pointy.String("accessToken-0001"), LimitName: pointy.String("daily"), CounterName: pointy.String("counter2"), VerifyType: pointy.String("less"), Count: pointy.Int32(10), MultiplyValueSpecifyingQuantity: 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\VerifyCounterRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->verifyCounter( (new VerifyCounterRequest()) ->withNamespaceName("namespace-0001") ->withAccessToken("accessToken-0001") ->withLimitName("daily") ->withCounterName("counter2") ->withVerifyType("less") ->withCount(10) ->withMultiplyValueSpecifyingQuantity(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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.VerifyCounterRequest; import io.gs2.limit.result.VerifyCounterResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { VerifyCounterResult result = client.verifyCounter( new VerifyCounterRequest() .withNamespaceName("namespace-0001") .withAccessToken("accessToken-0001") .withLimitName("daily") .withCounterName("counter2") .withVerifyType("less") .withCount(10) .withMultiplyValueSpecifyingQuantity(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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.VerifyCounterRequest; using Gs2.Gs2Limit.Result.VerifyCounterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.VerifyCounterResult> asyncResult = null; yield return client.VerifyCounter( new Gs2.Gs2Limit.Request.VerifyCounterRequest() .WithNamespaceName("namespace-0001") .WithAccessToken("accessToken-0001") .WithLimitName("daily") .WithCounterName("counter2") .WithVerifyType("less") .WithCount(10) .WithMultiplyValueSpecifyingQuantity(null), r => asyncResult = r ); if (asyncResult.Error != null) { throw asyncResult.Error; } var result = asyncResult.Result;
import Gs2Core from '@/gs2/core'; import * as Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.verifyCounter( new Gs2Limit.VerifyCounterRequest() .withNamespaceName("namespace-0001") .withAccessToken("accessToken-0001") .withLimitName("daily") .withCounterName("counter2") .withVerifyType("less") .withCount(10) .withMultiplyValueSpecifyingQuantity(null) ); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.verify_counter( limit.VerifyCounterRequest() .with_namespace_name('namespace-0001') .with_access_token('accessToken-0001') .with_limit_name('daily') .with_counter_name('counter2') .with_verify_type('less') .with_count(10) .with_multiply_value_specifying_quantity(None) ) except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.verify_counter({ namespaceName="namespace-0001", accessToken="accessToken-0001", limitName="daily", counterName="counter2", verifyType="less", count=10, multiplyValueSpecifyingQuantity=nil, }) if(api_result.isError) then -- When error occurs fail(api_result['statusCode'], api_result['message']) end result = api_result.result
client = gs2('limit') api_result_handler = client.verify_counter_async({ namespaceName="namespace-0001", accessToken="accessToken-0001", limitName="daily", counterName="counter2", verifyType="less", count=10, multiplyValueSpecifyingQuantity=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

verifyCounterByUserId

ユーザーIDを指定してカウンター値を検証

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
userIdstring~ 128文字ユーザーID
limitNamestring~ 128文字回数制限モデルの名前
counterNamestring~ 128文字カウンターの名前
verifyTypeenum {
    “less”,
    “lessEqual”,
    “greater”,
    “greaterEqual”,
    “equal”,
    “notEqual”
}
~ 128文字検証の種類
countint0~ 2147483646カウント値
multiplyValueSpecifyingQuantitybooltrue数量指定した際に、検証に使用する値も乗算するか
timeOffsetTokenstring~ 1024文字タイムオフセットトークン

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

定義説明
lessカウンター値が指定値未満であること
lessEqualカウンター値が指定値以下であること
greaterカウンター値が指定値超過であること
greaterEqualカウンター値が指定値以上であること
equalカウンター値が指定値と一致すること
notEqualカウンター値が指定値と一致しないこと

Result

説明

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.VerifyCounterByUserId( &limit.VerifyCounterByUserIdRequest { NamespaceName: pointy.String("namespace-0001"), UserId: pointy.String("user-0001"), LimitName: pointy.String("daily"), CounterName: pointy.String("counter2"), VerifyType: pointy.String("less"), Count: pointy.Int32(10), MultiplyValueSpecifyingQuantity: nil, 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\VerifyCounterByUserIdRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->verifyCounterByUserId( (new VerifyCounterByUserIdRequest()) ->withNamespaceName("namespace-0001") ->withUserId("user-0001") ->withLimitName("daily") ->withCounterName("counter2") ->withVerifyType("less") ->withCount(10) ->withMultiplyValueSpecifyingQuantity(null) ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.VerifyCounterByUserIdRequest; import io.gs2.limit.result.VerifyCounterByUserIdResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { VerifyCounterByUserIdResult result = client.verifyCounterByUserId( new VerifyCounterByUserIdRequest() .withNamespaceName("namespace-0001") .withUserId("user-0001") .withLimitName("daily") .withCounterName("counter2") .withVerifyType("less") .withCount(10) .withMultiplyValueSpecifyingQuantity(null) .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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.VerifyCounterByUserIdRequest; using Gs2.Gs2Limit.Result.VerifyCounterByUserIdResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.VerifyCounterByUserIdResult> asyncResult = null; yield return client.VerifyCounterByUserId( new Gs2.Gs2Limit.Request.VerifyCounterByUserIdRequest() .WithNamespaceName("namespace-0001") .WithUserId("user-0001") .WithLimitName("daily") .WithCounterName("counter2") .WithVerifyType("less") .WithCount(10) .WithMultiplyValueSpecifyingQuantity(null) .WithTimeOffsetToken(null), r => asyncResult = r ); if (asyncResult.Error != null) { throw asyncResult.Error; } var result = asyncResult.Result;
import Gs2Core from '@/gs2/core'; import * as Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.verifyCounterByUserId( new Gs2Limit.VerifyCounterByUserIdRequest() .withNamespaceName("namespace-0001") .withUserId("user-0001") .withLimitName("daily") .withCounterName("counter2") .withVerifyType("less") .withCount(10) .withMultiplyValueSpecifyingQuantity(null) .withTimeOffsetToken(null) ); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.verify_counter_by_user_id( limit.VerifyCounterByUserIdRequest() .with_namespace_name('namespace-0001') .with_user_id('user-0001') .with_limit_name('daily') .with_counter_name('counter2') .with_verify_type('less') .with_count(10) .with_multiply_value_specifying_quantity(None) .with_time_offset_token(None) ) except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.verify_counter_by_user_id({ namespaceName="namespace-0001", userId="user-0001", limitName="daily", counterName="counter2", verifyType="less", count=10, multiplyValueSpecifyingQuantity=nil, timeOffsetToken=nil, }) if(api_result.isError) then -- When error occurs fail(api_result['statusCode'], api_result['message']) end result = api_result.result
client = gs2('limit') api_result_handler = client.verify_counter_by_user_id_async({ namespaceName="namespace-0001", userId="user-0001", limitName="daily", counterName="counter2", verifyType="less", count=10, multiplyValueSpecifyingQuantity=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

countUpByStampTask

消費アクションとしてカウントアップを実行

Request

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

Result

説明
itemCounterカウントを増やしたカウンター
newContextStackstring消費アクションの実行結果を記録したコンテキスト

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CountUpByStampTask( &limit.CountUpByStampTaskRequest { StampTask: pointy.String("stampTask"), KeyId: pointy.String("key-0001"), } ) if err != nil { panic("error occurred") } item := result.Item newContextStack := result.NewContextStack
use Gs2\Core\Model\BasicGs2Credential; use Gs2\Core\Model\Region; use Gs2\Core\Net\Gs2RestSession; use Gs2\Core\Exception\Gs2Exception; use Gs2\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\CountUpByStampTaskRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->countUpByStampTask( (new CountUpByStampTaskRequest()) ->withStampTask("stampTask") ->withKeyId("key-0001") ); $item = $result->getItem(); $newContextStack = $result->getNewContextStack(); } 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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CountUpByStampTaskRequest; import io.gs2.limit.result.CountUpByStampTaskResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { CountUpByStampTaskResult result = client.countUpByStampTask( new CountUpByStampTaskRequest() .withStampTask("stampTask") .withKeyId("key-0001") ); Counter item = result.getItem(); String newContextStack = result.getNewContextStack(); } 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CountUpByStampTaskRequest; using Gs2.Gs2Limit.Result.CountUpByStampTaskResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CountUpByStampTaskResult> asyncResult = null; yield return client.CountUpByStampTask( new Gs2.Gs2Limit.Request.CountUpByStampTaskRequest() .WithStampTask("stampTask") .WithKeyId("key-0001"), r => asyncResult = r ); if (asyncResult.Error != null) { throw asyncResult.Error; } var result = asyncResult.Result; var item = result.Item; var newContextStack = result.NewContextStack;
import Gs2Core from '@/gs2/core'; import * as Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.countUpByStampTask( new Gs2Limit.CountUpByStampTaskRequest() .withStampTask("stampTask") .withKeyId("key-0001") ); const item = result.getItem(); const newContextStack = result.getNewContextStack(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.count_up_by_stamp_task( limit.CountUpByStampTaskRequest() .with_stamp_task('stampTask') .with_key_id('key-0001') ) item = result.item new_context_stack = result.new_context_stack except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.count_up_by_stamp_task({ stampTask="stampTask", 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; newContextStack = result.newContextStack;
client = gs2('limit') api_result_handler = client.count_up_by_stamp_task_async({ stampTask="stampTask", 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; newContextStack = result.newContextStack;

countDownByStampSheet

入手アクションとしてカウントダウンを実行

Request

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

Result

説明
itemCounter削除したカウンター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CountDownByStampSheet( &limit.CountDownByStampSheetRequest { 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\CountDownByStampSheetRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->countDownByStampSheet( (new CountDownByStampSheetRequest()) ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CountDownByStampSheetRequest; import io.gs2.limit.result.CountDownByStampSheetResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { CountDownByStampSheetResult result = client.countDownByStampSheet( new CountDownByStampSheetRequest() .withStampSheet("stampSheet") .withKeyId("key-0001") ); Counter 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CountDownByStampSheetRequest; using Gs2.Gs2Limit.Result.CountDownByStampSheetResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CountDownByStampSheetResult> asyncResult = null; yield return client.CountDownByStampSheet( new Gs2.Gs2Limit.Request.CountDownByStampSheetRequest() .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.countDownByStampSheet( new Gs2Limit.CountDownByStampSheetRequest() .withStampSheet("stampSheet") .withKeyId("key-0001") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.count_down_by_stamp_sheet( limit.CountDownByStampSheetRequest() .with_stamp_sheet('stampSheet') .with_key_id('key-0001') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.count_down_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('limit') api_result_handler = client.count_down_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;

deleteByStampSheet

入手アクションとしてカウンターの削除を実行

Request

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

Result

説明
itemCounter削除したカウンター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.DeleteByStampSheet( &limit.DeleteByStampSheetRequest { 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\DeleteByStampSheetRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->deleteByStampSheet( (new DeleteByStampSheetRequest()) ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.DeleteByStampSheetRequest; import io.gs2.limit.result.DeleteByStampSheetResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { DeleteByStampSheetResult result = client.deleteByStampSheet( new DeleteByStampSheetRequest() .withStampSheet("stampSheet") .withKeyId("key-0001") ); Counter 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.DeleteByStampSheetRequest; using Gs2.Gs2Limit.Result.DeleteByStampSheetResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.DeleteByStampSheetResult> asyncResult = null; yield return client.DeleteByStampSheet( new Gs2.Gs2Limit.Request.DeleteByStampSheetRequest() .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.deleteByStampSheet( new Gs2Limit.DeleteByStampSheetRequest() .withStampSheet("stampSheet") .withKeyId("key-0001") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.delete_by_stamp_sheet( limit.DeleteByStampSheetRequest() .with_stamp_sheet('stampSheet') .with_key_id('key-0001') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.delete_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('limit') api_result_handler = client.delete_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;

verifyCounterByStampTask

検証アクションとしてカウンター値の検証を実行

Request

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

Result

説明
newContextStackstring検証アクションの実行結果を記録したコンテキスト

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.VerifyCounterByStampTask( &limit.VerifyCounterByStampTaskRequest { StampTask: pointy.String("stampTask"), KeyId: pointy.String("key-0001"), } ) if err != nil { panic("error occurred") } newContextStack := result.NewContextStack
use Gs2\Core\Model\BasicGs2Credential; use Gs2\Core\Model\Region; use Gs2\Core\Net\Gs2RestSession; use Gs2\Core\Exception\Gs2Exception; use Gs2\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\VerifyCounterByStampTaskRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->verifyCounterByStampTask( (new VerifyCounterByStampTaskRequest()) ->withStampTask("stampTask") ->withKeyId("key-0001") ); $newContextStack = $result->getNewContextStack(); } 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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.VerifyCounterByStampTaskRequest; import io.gs2.limit.result.VerifyCounterByStampTaskResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { VerifyCounterByStampTaskResult result = client.verifyCounterByStampTask( new VerifyCounterByStampTaskRequest() .withStampTask("stampTask") .withKeyId("key-0001") ); String newContextStack = result.getNewContextStack(); } 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.VerifyCounterByStampTaskRequest; using Gs2.Gs2Limit.Result.VerifyCounterByStampTaskResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.VerifyCounterByStampTaskResult> asyncResult = null; yield return client.VerifyCounterByStampTask( new Gs2.Gs2Limit.Request.VerifyCounterByStampTaskRequest() .WithStampTask("stampTask") .WithKeyId("key-0001"), r => asyncResult = r ); if (asyncResult.Error != null) { throw asyncResult.Error; } var result = asyncResult.Result; var newContextStack = result.NewContextStack;
import Gs2Core from '@/gs2/core'; import * as Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.verifyCounterByStampTask( new Gs2Limit.VerifyCounterByStampTaskRequest() .withStampTask("stampTask") .withKeyId("key-0001") ); const newContextStack = result.getNewContextStack(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.verify_counter_by_stamp_task( limit.VerifyCounterByStampTaskRequest() .with_stamp_task('stampTask') .with_key_id('key-0001') ) new_context_stack = result.new_context_stack except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.verify_counter_by_stamp_task({ stampTask="stampTask", keyId="key-0001", }) if(api_result.isError) then -- When error occurs fail(api_result['statusCode'], api_result['message']) end result = api_result.result newContextStack = result.newContextStack;
client = gs2('limit') api_result_handler = client.verify_counter_by_stamp_task_async({ stampTask="stampTask", 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 newContextStack = result.newContextStack;

describeLimitModelMasters

回数制限モデルマスターの一覧を取得

Request

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

Result

説明
itemsList<LimitModelMaster>回数制限モデルマスターのリスト
nextPageTokenstringリストの続きを取得するためのページトークン

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.DescribeLimitModelMasters( &limit.DescribeLimitModelMastersRequest { 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\DescribeLimitModelMastersRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->describeLimitModelMasters( (new DescribeLimitModelMastersRequest()) ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.DescribeLimitModelMastersRequest; import io.gs2.limit.result.DescribeLimitModelMastersResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { DescribeLimitModelMastersResult result = client.describeLimitModelMasters( new DescribeLimitModelMastersRequest() .withNamespaceName("namespace-0001") .withPageToken(null) .withLimit(null) ); List<LimitModelMaster> 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.DescribeLimitModelMastersRequest; using Gs2.Gs2Limit.Result.DescribeLimitModelMastersResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.DescribeLimitModelMastersResult> asyncResult = null; yield return client.DescribeLimitModelMasters( new Gs2.Gs2Limit.Request.DescribeLimitModelMastersRequest() .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.describeLimitModelMasters( new Gs2Limit.DescribeLimitModelMastersRequest() .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 limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.describe_limit_model_masters( limit.DescribeLimitModelMastersRequest() .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('limit') api_result = client.describe_limit_model_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('limit') api_result_handler = client.describe_limit_model_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;

createLimitModelMaster

回数制限モデルマスターを新規作成

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
namestring~ 128文字回数制限モデル名
descriptionstring~ 1024文字説明文
metadatastring~ 2048文字メタデータ
resetTypeenum {
    “notReset”,
    “daily”,
    “weekly”,
    “monthly”,
    “days”
}
~ 128文字リセットタイミング
resetDayOfMonthint{resetType} == “monthly”1 ~ 31リセットをする日にち(月の日数を超える場合は、最終日として扱われます)
resetDayOfWeekenum {
    “sunday”,
    “monday”,
    “tuesday”,
    “wednesday”,
    “thursday”,
    “friday”,
    “saturday”
}
{resetType} == “weekly”~ 128文字リセットする曜日
resetHourint{resetType} in [“monthly”, “weekly”, “daily”]~ 23リセット時刻
anchorTimestamplong{resetType} == “days”経過日数のカウントをする基準日 (UNIX時間 単位:ミリ秒)
daysint{resetType} == “days”1 ~ 2147483646リセットする日数

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

定義説明
notResetリセットしない
daily毎日
weekly毎週
monthly毎月
days一定日数

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

定義説明
sunday日曜日
monday月曜日
tuesday火曜日
wednesday水曜日
thursday木曜日
friday金曜日
saturday土曜日

Result

説明
itemLimitModelMaster作成した回数制限モデルマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.CreateLimitModelMaster( &limit.CreateLimitModelMasterRequest { NamespaceName: pointy.String("namespace-0001"), Name: pointy.String("limit-model-0001"), Description: nil, Metadata: nil, ResetType: pointy.String("monthly"), ResetDayOfMonth: pointy.Int32(1), ResetDayOfWeek: pointy.String("monday"), ResetHour: pointy.Int32(5), AnchorTimestamp: pointy.Int64(1000), Days: pointy.Int32(10), } ) 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\CreateLimitModelMasterRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->createLimitModelMaster( (new CreateLimitModelMasterRequest()) ->withNamespaceName("namespace-0001") ->withName("limit-model-0001") ->withDescription(null) ->withMetadata(null) ->withResetType("monthly") ->withResetDayOfMonth(1) ->withResetDayOfWeek("monday") ->withResetHour(5) ->withAnchorTimestamp(1000) ->withDays(10) ); $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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.CreateLimitModelMasterRequest; import io.gs2.limit.result.CreateLimitModelMasterResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { CreateLimitModelMasterResult result = client.createLimitModelMaster( new CreateLimitModelMasterRequest() .withNamespaceName("namespace-0001") .withName("limit-model-0001") .withDescription(null) .withMetadata(null) .withResetType("monthly") .withResetDayOfMonth(1) .withResetDayOfWeek("monday") .withResetHour(5) .withAnchorTimestamp(1000L) .withDays(10) ); LimitModelMaster 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.CreateLimitModelMasterRequest; using Gs2.Gs2Limit.Result.CreateLimitModelMasterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.CreateLimitModelMasterResult> asyncResult = null; yield return client.CreateLimitModelMaster( new Gs2.Gs2Limit.Request.CreateLimitModelMasterRequest() .WithNamespaceName("namespace-0001") .WithName("limit-model-0001") .WithDescription(null) .WithMetadata(null) .WithResetType("monthly") .WithResetDayOfMonth(1) .WithResetDayOfWeek("monday") .WithResetHour(5) .WithAnchorTimestamp(1000L) .WithDays(10), 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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.createLimitModelMaster( new Gs2Limit.CreateLimitModelMasterRequest() .withNamespaceName("namespace-0001") .withName("limit-model-0001") .withDescription(null) .withMetadata(null) .withResetType("monthly") .withResetDayOfMonth(1) .withResetDayOfWeek("monday") .withResetHour(5) .withAnchorTimestamp(1000) .withDays(10) ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.create_limit_model_master( limit.CreateLimitModelMasterRequest() .with_namespace_name('namespace-0001') .with_name('limit-model-0001') .with_description(None) .with_metadata(None) .with_reset_type('monthly') .with_reset_day_of_month(1) .with_reset_day_of_week('monday') .with_reset_hour(5) .with_anchor_timestamp(1000) .with_days(10) ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.create_limit_model_master({ namespaceName="namespace-0001", name="limit-model-0001", description=nil, metadata=nil, resetType="monthly", resetDayOfMonth=1, resetDayOfWeek="monday", resetHour=5, anchorTimestamp=1000, days=10, }) 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('limit') api_result_handler = client.create_limit_model_master_async({ namespaceName="namespace-0001", name="limit-model-0001", description=nil, metadata=nil, resetType="monthly", resetDayOfMonth=1, resetDayOfWeek="monday", resetHour=5, anchorTimestamp=1000, days=10, }) api_result = api_result_handler() -- Call the handler to get the result if(api_result.isError) then -- When error occurs fail(api_result['statusCode'], api_result['message']) end result = api_result.result item = result.item;

getLimitModelMaster

回数制限モデルマスターを取得

Request

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

Result

説明
itemLimitModelMaster回数制限モデルマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.GetLimitModelMaster( &limit.GetLimitModelMasterRequest { NamespaceName: pointy.String("namespace-0001"), LimitName: pointy.String("limit-model-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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\GetLimitModelMasterRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->getLimitModelMaster( (new GetLimitModelMasterRequest()) ->withNamespaceName("namespace-0001") ->withLimitName("limit-model-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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.GetLimitModelMasterRequest; import io.gs2.limit.result.GetLimitModelMasterResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { GetLimitModelMasterResult result = client.getLimitModelMaster( new GetLimitModelMasterRequest() .withNamespaceName("namespace-0001") .withLimitName("limit-model-0001") ); LimitModelMaster 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.GetLimitModelMasterRequest; using Gs2.Gs2Limit.Result.GetLimitModelMasterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.GetLimitModelMasterResult> asyncResult = null; yield return client.GetLimitModelMaster( new Gs2.Gs2Limit.Request.GetLimitModelMasterRequest() .WithNamespaceName("namespace-0001") .WithLimitName("limit-model-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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.getLimitModelMaster( new Gs2Limit.GetLimitModelMasterRequest() .withNamespaceName("namespace-0001") .withLimitName("limit-model-0001") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.get_limit_model_master( limit.GetLimitModelMasterRequest() .with_namespace_name('namespace-0001') .with_limit_name('limit-model-0001') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.get_limit_model_master({ namespaceName="namespace-0001", limitName="limit-model-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('limit') api_result_handler = client.get_limit_model_master_async({ namespaceName="namespace-0001", limitName="limit-model-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;

updateLimitModelMaster

回数制限モデルマスターを更新

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
limitNamestring~ 128文字回数制限モデル名
descriptionstring~ 1024文字説明文
metadatastring~ 2048文字メタデータ
resetTypeenum {
    “notReset”,
    “daily”,
    “weekly”,
    “monthly”,
    “days”
}
~ 128文字リセットタイミング
resetDayOfMonthint{resetType} == “monthly”1 ~ 31リセットをする日にち(月の日数を超える場合は、最終日として扱われます)
resetDayOfWeekenum {
    “sunday”,
    “monday”,
    “tuesday”,
    “wednesday”,
    “thursday”,
    “friday”,
    “saturday”
}
{resetType} == “weekly”~ 128文字リセットする曜日
resetHourint{resetType} in [“monthly”, “weekly”, “daily”]~ 23リセット時刻
anchorTimestamplong{resetType} == “days”経過日数のカウントをする基準日 (UNIX時間 単位:ミリ秒)
daysint{resetType} == “days”1 ~ 2147483646リセットする日数

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

定義説明
notResetリセットしない
daily毎日
weekly毎週
monthly毎月
days一定日数

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

定義説明
sunday日曜日
monday月曜日
tuesday火曜日
wednesday水曜日
thursday木曜日
friday金曜日
saturday土曜日

Result

説明
itemLimitModelMaster更新した回数制限モデルマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.UpdateLimitModelMaster( &limit.UpdateLimitModelMasterRequest { NamespaceName: pointy.String("namespace-0001"), LimitName: pointy.String("limit-model-0001"), Description: pointy.String("description1"), Metadata: pointy.String("{\"hoge\": \"fuga\"}"), ResetType: pointy.String("daily"), ResetDayOfMonth: pointy.Int32(1), ResetDayOfWeek: pointy.String("monday"), ResetHour: pointy.Int32(18), AnchorTimestamp: pointy.Int64(2000), Days: pointy.Int32(5), } ) 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\UpdateLimitModelMasterRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->updateLimitModelMaster( (new UpdateLimitModelMasterRequest()) ->withNamespaceName("namespace-0001") ->withLimitName("limit-model-0001") ->withDescription("description1") ->withMetadata("{\"hoge\": \"fuga\"}") ->withResetType("daily") ->withResetDayOfMonth(1) ->withResetDayOfWeek("monday") ->withResetHour(18) ->withAnchorTimestamp(2000) ->withDays(5) ); $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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.UpdateLimitModelMasterRequest; import io.gs2.limit.result.UpdateLimitModelMasterResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { UpdateLimitModelMasterResult result = client.updateLimitModelMaster( new UpdateLimitModelMasterRequest() .withNamespaceName("namespace-0001") .withLimitName("limit-model-0001") .withDescription("description1") .withMetadata("{\"hoge\": \"fuga\"}") .withResetType("daily") .withResetDayOfMonth(1) .withResetDayOfWeek("monday") .withResetHour(18) .withAnchorTimestamp(2000L) .withDays(5) ); LimitModelMaster 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.UpdateLimitModelMasterRequest; using Gs2.Gs2Limit.Result.UpdateLimitModelMasterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.UpdateLimitModelMasterResult> asyncResult = null; yield return client.UpdateLimitModelMaster( new Gs2.Gs2Limit.Request.UpdateLimitModelMasterRequest() .WithNamespaceName("namespace-0001") .WithLimitName("limit-model-0001") .WithDescription("description1") .WithMetadata("{\"hoge\": \"fuga\"}") .WithResetType("daily") .WithResetDayOfMonth(1) .WithResetDayOfWeek("monday") .WithResetHour(18) .WithAnchorTimestamp(2000L) .WithDays(5), 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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.updateLimitModelMaster( new Gs2Limit.UpdateLimitModelMasterRequest() .withNamespaceName("namespace-0001") .withLimitName("limit-model-0001") .withDescription("description1") .withMetadata("{\"hoge\": \"fuga\"}") .withResetType("daily") .withResetDayOfMonth(1) .withResetDayOfWeek("monday") .withResetHour(18) .withAnchorTimestamp(2000) .withDays(5) ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.update_limit_model_master( limit.UpdateLimitModelMasterRequest() .with_namespace_name('namespace-0001') .with_limit_name('limit-model-0001') .with_description('description1') .with_metadata('{"hoge": "fuga"}') .with_reset_type('daily') .with_reset_day_of_month(1) .with_reset_day_of_week('monday') .with_reset_hour(18) .with_anchor_timestamp(2000) .with_days(5) ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.update_limit_model_master({ namespaceName="namespace-0001", limitName="limit-model-0001", description="description1", metadata="{\"hoge\": \"fuga\"}", resetType="daily", resetDayOfMonth=1, resetDayOfWeek="monday", resetHour=18, anchorTimestamp=2000, days=5, }) 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('limit') api_result_handler = client.update_limit_model_master_async({ namespaceName="namespace-0001", limitName="limit-model-0001", description="description1", metadata="{\"hoge\": \"fuga\"}", resetType="daily", resetDayOfMonth=1, resetDayOfWeek="monday", resetHour=18, anchorTimestamp=2000, days=5, }) 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;

deleteLimitModelMaster

回数制限モデルマスターを削除

Request

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

Result

説明
itemLimitModelMaster削除した回数制限モデルマスター

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.DeleteLimitModelMaster( &limit.DeleteLimitModelMasterRequest { NamespaceName: pointy.String("namespace-0001"), LimitName: pointy.String("limit-model-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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\DeleteLimitModelMasterRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->deleteLimitModelMaster( (new DeleteLimitModelMasterRequest()) ->withNamespaceName("namespace-0001") ->withLimitName("limit-model-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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.DeleteLimitModelMasterRequest; import io.gs2.limit.result.DeleteLimitModelMasterResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { DeleteLimitModelMasterResult result = client.deleteLimitModelMaster( new DeleteLimitModelMasterRequest() .withNamespaceName("namespace-0001") .withLimitName("limit-model-0001") ); LimitModelMaster 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.DeleteLimitModelMasterRequest; using Gs2.Gs2Limit.Result.DeleteLimitModelMasterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.DeleteLimitModelMasterResult> asyncResult = null; yield return client.DeleteLimitModelMaster( new Gs2.Gs2Limit.Request.DeleteLimitModelMasterRequest() .WithNamespaceName("namespace-0001") .WithLimitName("limit-model-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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.deleteLimitModelMaster( new Gs2Limit.DeleteLimitModelMasterRequest() .withNamespaceName("namespace-0001") .withLimitName("limit-model-0001") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.delete_limit_model_master( limit.DeleteLimitModelMasterRequest() .with_namespace_name('namespace-0001') .with_limit_name('limit-model-0001') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.delete_limit_model_master({ namespaceName="namespace-0001", limitName="limit-model-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('limit') api_result_handler = client.delete_limit_model_master_async({ namespaceName="namespace-0001", limitName="limit-model-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;

exportMaster

現在有効な回数制限設定のマスターデータをエクスポート

Request

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

Result

説明
itemCurrentLimitMaster現在有効な回数制限設定

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.ExportMaster( &limit.ExportMasterRequest { 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\ExportMasterRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->exportMaster( (new ExportMasterRequest()) ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.ExportMasterRequest; import io.gs2.limit.result.ExportMasterResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { ExportMasterResult result = client.exportMaster( new ExportMasterRequest() .withNamespaceName("namespace-0001") ); CurrentLimitMaster 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.ExportMasterRequest; using Gs2.Gs2Limit.Result.ExportMasterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.ExportMasterResult> asyncResult = null; yield return client.ExportMaster( new Gs2.Gs2Limit.Request.ExportMasterRequest() .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.exportMaster( new Gs2Limit.ExportMasterRequest() .withNamespaceName("namespace-0001") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.export_master( limit.ExportMasterRequest() .with_namespace_name('namespace-0001') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.export_master({ 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('limit') api_result_handler = client.export_master_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;

getCurrentLimitMaster

現在有効な回数制限設定を取得

Request

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

Result

説明
itemCurrentLimitMaster現在有効な回数制限設定

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.GetCurrentLimitMaster( &limit.GetCurrentLimitMasterRequest { 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\GetCurrentLimitMasterRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->getCurrentLimitMaster( (new GetCurrentLimitMasterRequest()) ->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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.GetCurrentLimitMasterRequest; import io.gs2.limit.result.GetCurrentLimitMasterResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { GetCurrentLimitMasterResult result = client.getCurrentLimitMaster( new GetCurrentLimitMasterRequest() .withNamespaceName("namespace-0001") ); CurrentLimitMaster 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.GetCurrentLimitMasterRequest; using Gs2.Gs2Limit.Result.GetCurrentLimitMasterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.GetCurrentLimitMasterResult> asyncResult = null; yield return client.GetCurrentLimitMaster( new Gs2.Gs2Limit.Request.GetCurrentLimitMasterRequest() .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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.getCurrentLimitMaster( new Gs2Limit.GetCurrentLimitMasterRequest() .withNamespaceName("namespace-0001") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.get_current_limit_master( limit.GetCurrentLimitMasterRequest() .with_namespace_name('namespace-0001') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.get_current_limit_master({ 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('limit') api_result_handler = client.get_current_limit_master_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;

updateCurrentLimitMaster

現在有効な回数制限設定を更新

Request

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

Result

説明
itemCurrentLimitMaster更新した現在有効な回数制限設定

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.UpdateCurrentLimitMaster( &limit.UpdateCurrentLimitMasterRequest { NamespaceName: pointy.String("namespace-0001"), Settings: pointy.String("{\n \"version\": \"2019-04-05\",\n \"limitModels\": [\n {\n \"name\": \"daily\",\n \"metadata\": \"DAILY\",\n \"resetType\": \"daily\",\n \"resetHour\": 9\n },\n {\n \"name\": \"weekly\",\n \"metadata\": \"WEEKLY\",\n \"resetType\": \"weekly\",\n \"resetDayOfWeek\": \"sunday\",\n \"resetHour\": 18\n }\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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\UpdateCurrentLimitMasterRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->updateCurrentLimitMaster( (new UpdateCurrentLimitMasterRequest()) ->withNamespaceName("namespace-0001") ->withSettings("{\n \"version\": \"2019-04-05\",\n \"limitModels\": [\n {\n \"name\": \"daily\",\n \"metadata\": \"DAILY\",\n \"resetType\": \"daily\",\n \"resetHour\": 9\n },\n {\n \"name\": \"weekly\",\n \"metadata\": \"WEEKLY\",\n \"resetType\": \"weekly\",\n \"resetDayOfWeek\": \"sunday\",\n \"resetHour\": 18\n }\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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.UpdateCurrentLimitMasterRequest; import io.gs2.limit.result.UpdateCurrentLimitMasterResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { UpdateCurrentLimitMasterResult result = client.updateCurrentLimitMaster( new UpdateCurrentLimitMasterRequest() .withNamespaceName("namespace-0001") .withSettings("{\n \"version\": \"2019-04-05\",\n \"limitModels\": [\n {\n \"name\": \"daily\",\n \"metadata\": \"DAILY\",\n \"resetType\": \"daily\",\n \"resetHour\": 9\n },\n {\n \"name\": \"weekly\",\n \"metadata\": \"WEEKLY\",\n \"resetType\": \"weekly\",\n \"resetDayOfWeek\": \"sunday\",\n \"resetHour\": 18\n }\n ]\n}") ); CurrentLimitMaster 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.UpdateCurrentLimitMasterRequest; using Gs2.Gs2Limit.Result.UpdateCurrentLimitMasterResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.UpdateCurrentLimitMasterResult> asyncResult = null; yield return client.UpdateCurrentLimitMaster( new Gs2.Gs2Limit.Request.UpdateCurrentLimitMasterRequest() .WithNamespaceName("namespace-0001") .WithSettings("{\n \"version\": \"2019-04-05\",\n \"limitModels\": [\n {\n \"name\": \"daily\",\n \"metadata\": \"DAILY\",\n \"resetType\": \"daily\",\n \"resetHour\": 9\n },\n {\n \"name\": \"weekly\",\n \"metadata\": \"WEEKLY\",\n \"resetType\": \"weekly\",\n \"resetDayOfWeek\": \"sunday\",\n \"resetHour\": 18\n }\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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.updateCurrentLimitMaster( new Gs2Limit.UpdateCurrentLimitMasterRequest() .withNamespaceName("namespace-0001") .withSettings("{\n \"version\": \"2019-04-05\",\n \"limitModels\": [\n {\n \"name\": \"daily\",\n \"metadata\": \"DAILY\",\n \"resetType\": \"daily\",\n \"resetHour\": 9\n },\n {\n \"name\": \"weekly\",\n \"metadata\": \"WEEKLY\",\n \"resetType\": \"weekly\",\n \"resetDayOfWeek\": \"sunday\",\n \"resetHour\": 18\n }\n ]\n}") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.update_current_limit_master( limit.UpdateCurrentLimitMasterRequest() .with_namespace_name('namespace-0001') .with_settings('{\n "version": "2019-04-05",\n "limitModels": [\n {\n "name": "daily",\n "metadata": "DAILY",\n "resetType": "daily",\n "resetHour": 9\n },\n {\n "name": "weekly",\n "metadata": "WEEKLY",\n "resetType": "weekly",\n "resetDayOfWeek": "sunday",\n "resetHour": 18\n }\n ]\n}') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.update_current_limit_master({ namespaceName="namespace-0001", settings="{\n "version": "2019-04-05",\n "limitModels": [\n {\n "name": "daily",\n "metadata": "DAILY",\n "resetType": "daily",\n "resetHour": 9\n },\n {\n "name": "weekly",\n "metadata": "WEEKLY",\n "resetType": "weekly",\n "resetDayOfWeek": "sunday",\n "resetHour": 18\n }\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('limit') api_result_handler = client.update_current_limit_master_async({ namespaceName="namespace-0001", settings="{\n "version": "2019-04-05",\n "limitModels": [\n {\n "name": "daily",\n "metadata": "DAILY",\n "resetType": "daily",\n "resetHour": 9\n },\n {\n "name": "weekly",\n "metadata": "WEEKLY",\n "resetType": "weekly",\n "resetDayOfWeek": "sunday",\n "resetHour": 18\n }\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;

updateCurrentLimitMasterFromGitHub

現在有効な回数制限設定を更新

Request

有効化条件必須デフォルト値の制限説明
namespaceNamestring~ 128文字ネームスペース名
checkoutSettingGitHubCheckoutSettingGitHubからマスターデータをチェックアウトしてくる設定

Result

説明
itemCurrentLimitMaster更新した現在有効な回数制限設定

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.UpdateCurrentLimitMasterFromGitHub( &limit.UpdateCurrentLimitMasterFromGitHubRequest { NamespaceName: pointy.String("namespace-0001"), CheckoutSetting: &limit.GitHubCheckoutSetting{ ApiKeyId: pointy.String("apiKeyId-0001"), RepositoryName: pointy.String("gs2io/master-data"), SourcePath: pointy.String("path/to/file.json"), ReferenceType: pointy.String("branch"), BranchName: pointy.String("develop"), }, } ) 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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\UpdateCurrentLimitMasterFromGitHubRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->updateCurrentLimitMasterFromGitHub( (new UpdateCurrentLimitMasterFromGitHubRequest()) ->withNamespaceName("namespace-0001") ->withCheckoutSetting((new GitHubCheckoutSetting()) ->withApiKeyId("apiKeyId-0001") ->withRepositoryName("gs2io/master-data") ->withSourcePath("path/to/file.json") ->withReferenceType("branch") ->withBranchName("develop") ) ); $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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.UpdateCurrentLimitMasterFromGitHubRequest; import io.gs2.limit.result.UpdateCurrentLimitMasterFromGitHubResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { UpdateCurrentLimitMasterFromGitHubResult result = client.updateCurrentLimitMasterFromGitHub( new UpdateCurrentLimitMasterFromGitHubRequest() .withNamespaceName("namespace-0001") .withCheckoutSetting(new GitHubCheckoutSetting() .withApiKeyId("apiKeyId-0001") .withRepositoryName("gs2io/master-data") .withSourcePath("path/to/file.json") .withReferenceType("branch") .withBranchName("develop") ) ); CurrentLimitMaster 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.UpdateCurrentLimitMasterFromGitHubRequest; using Gs2.Gs2Limit.Result.UpdateCurrentLimitMasterFromGitHubResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.UpdateCurrentLimitMasterFromGitHubResult> asyncResult = null; yield return client.UpdateCurrentLimitMasterFromGitHub( new Gs2.Gs2Limit.Request.UpdateCurrentLimitMasterFromGitHubRequest() .WithNamespaceName("namespace-0001") .WithCheckoutSetting(new Gs2.Gs2Limit.Model.GitHubCheckoutSetting() .WithApiKeyId("apiKeyId-0001") .WithRepositoryName("gs2io/master-data") .WithSourcePath("path/to/file.json") .WithReferenceType("branch") .WithBranchName("develop") ), 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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.updateCurrentLimitMasterFromGitHub( new Gs2Limit.UpdateCurrentLimitMasterFromGitHubRequest() .withNamespaceName("namespace-0001") .withCheckoutSetting(new Gs2Limit.model.GitHubCheckoutSetting() .withApiKeyId("apiKeyId-0001") .withRepositoryName("gs2io/master-data") .withSourcePath("path/to/file.json") .withReferenceType("branch") .withBranchName("develop") ) ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.update_current_limit_master_from_git_hub( limit.UpdateCurrentLimitMasterFromGitHubRequest() .with_namespace_name('namespace-0001') .with_checkout_setting(limit.GitHubCheckoutSetting() .with_api_key_id('apiKeyId-0001') .with_repository_name('gs2io/master-data') .with_source_path('path/to/file.json') .with_reference_type('branch') .with_branch_name('develop') ) ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.update_current_limit_master_from_git_hub({ namespaceName="namespace-0001", checkoutSetting={ api_key_id="apiKeyId-0001", repository_name="gs2io/master-data", source_path="path/to/file.json", reference_type="branch", branch_name="develop", }, }) 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('limit') api_result_handler = client.update_current_limit_master_from_git_hub_async({ namespaceName="namespace-0001", checkoutSetting={ api_key_id="apiKeyId-0001", repository_name="gs2io/master-data", source_path="path/to/file.json", reference_type="branch", branch_name="develop", }, }) 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;

describeLimitModels

回数制限モデルの一覧を取得

Request

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

Result

説明
itemsList<LimitModel>回数制限モデルのリスト

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.DescribeLimitModels( &limit.DescribeLimitModelsRequest { NamespaceName: pointy.String("namespace-0001"), } ) if err != nil { panic("error occurred") } items := result.Items
use Gs2\Core\Model\BasicGs2Credential; use Gs2\Core\Model\Region; use Gs2\Core\Net\Gs2RestSession; use Gs2\Core\Exception\Gs2Exception; use Gs2\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\DescribeLimitModelsRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->describeLimitModels( (new DescribeLimitModelsRequest()) ->withNamespaceName("namespace-0001") ); $items = $result->getItems(); } 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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.DescribeLimitModelsRequest; import io.gs2.limit.result.DescribeLimitModelsResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { DescribeLimitModelsResult result = client.describeLimitModels( new DescribeLimitModelsRequest() .withNamespaceName("namespace-0001") ); List<LimitModel> items = result.getItems(); } 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.DescribeLimitModelsRequest; using Gs2.Gs2Limit.Result.DescribeLimitModelsResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.DescribeLimitModelsResult> asyncResult = null; yield return client.DescribeLimitModels( new Gs2.Gs2Limit.Request.DescribeLimitModelsRequest() .WithNamespaceName("namespace-0001"), r => asyncResult = r ); if (asyncResult.Error != null) { throw asyncResult.Error; } var result = asyncResult.Result; var items = result.Items;
import Gs2Core from '@/gs2/core'; import * as Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.describeLimitModels( new Gs2Limit.DescribeLimitModelsRequest() .withNamespaceName("namespace-0001") ); const items = result.getItems(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.describe_limit_models( limit.DescribeLimitModelsRequest() .with_namespace_name('namespace-0001') ) items = result.items except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.describe_limit_models({ namespaceName="namespace-0001", }) if(api_result.isError) then -- When error occurs fail(api_result['statusCode'], api_result['message']) end result = api_result.result items = result.items;
client = gs2('limit') api_result_handler = client.describe_limit_models_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 items = result.items;

getLimitModel

回数制限モデルを取得

Request

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

Result

説明
itemLimitModel回数制限モデル

実装例

import "github.com/gs2io/gs2-golang-sdk/core" import "github.com/gs2io/gs2-golang-sdk/limit" 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 := limit.Gs2LimitRestClient{ Session: &session, } result, err := client.GetLimitModel( &limit.GetLimitModelRequest { NamespaceName: pointy.String("namespace-0001"), LimitName: pointy.String("limit-model-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\Limit\Gs2LimitRestClient; use Gs2\Limit\Request\GetLimitModelRequest; $session = new Gs2RestSession( new BasicGs2Credential( "your client id", "your client secret" ), Region::AP_NORTHEAST_1 ); $session->open(); $client = new Gs2AccountRestClient( $session ); try { $result = $client->getLimitModel( (new GetLimitModelRequest()) ->withNamespaceName("namespace-0001") ->withLimitName("limit-model-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.limit.rest.Gs2LimitRestClient; import io.gs2.limit.request.GetLimitModelRequest; import io.gs2.limit.result.GetLimitModelResult; Gs2RestSession session = new Gs2RestSession( Region.AP_NORTHEAST_1, new BasicGs2Credential( 'your client id', 'your client secret' ) ); session.connect(); Gs2LimitRestClient client = new Gs2LimitRestClient(session); try { GetLimitModelResult result = client.getLimitModel( new GetLimitModelRequest() .withNamespaceName("namespace-0001") .withLimitName("limit-model-0001") ); LimitModel 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.Gs2Limit.Gs2LimitRestClient; using Gs2.Gs2Limit.Request.GetLimitModelRequest; using Gs2.Gs2Limit.Result.GetLimitModelResult; var session = new Gs2RestSession( new BasicGs2Credential( 'your client id', 'your client secret' ), Region.ApNortheast1 ); yield return session.Open(); var client = new Gs2LimitRestClient(session); AsyncResult<Gs2.Gs2Limit.Result.GetLimitModelResult> asyncResult = null; yield return client.GetLimitModel( new Gs2.Gs2Limit.Request.GetLimitModelRequest() .WithNamespaceName("namespace-0001") .WithLimitName("limit-model-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 Gs2Limit from '@/gs2/limit'; const session = new Gs2Core.Gs2RestSession( "ap-northeast-1", new Gs2Core.BasicGs2Credential( 'your client id', 'your client secret' ) ); await session.connect(); const client = new Gs2Limit.Gs2LimitRestClient(session); try { const result = await client.getLimitModel( new Gs2Limit.GetLimitModelRequest() .withNamespaceName("namespace-0001") .withLimitName("limit-model-0001") ); const item = result.getItem(); } catch (e) { process.exit(1); }
from gs2 import core from gs2 import limit session = core.Gs2RestSession( core.BasicGs2Credential( 'your client id', 'your client secret' ), "ap-northeast-1", ) session.connect() client = limit.Gs2LimitRestClient(session) try: result = client.get_limit_model( limit.GetLimitModelRequest() .with_namespace_name('namespace-0001') .with_limit_name('limit-model-0001') ) item = result.item except core.Gs2Exception as e: exit(1)
client = gs2('limit') api_result = client.get_limit_model({ namespaceName="namespace-0001", limitName="limit-model-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('limit') api_result_handler = client.get_limit_model_async({ namespaceName="namespace-0001", limitName="limit-model-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;