NAV Navbar
Python Java GS2-Formation
 

GS2-Limit

回数制限処理を実現するためのサービス

このサービスは単独で使うのではなく 他のサービスで回数制限機能を実現します。

GS2-Limit のデータ構造は以下です。

モデル

Namespace

ネームスペース

ネームスペースには回数制限モデル(回数制限に使用するカウンターの種類やカウント期間情報)を最大100種類指定できます。 100種類超える見込みがある場合はネームスペースを回数制限のカテゴリごとに分割することを事前に検討してください。

ネームスペースを分割することで生じるデメリットとして、特定のゲームプレイヤーに関するカウンターの一覧を取得したり、回数制限のマスターデータを取得する際にネームスペースを超えて同時に取得することはできないことがあります。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false ネームスペースの説明
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

Counter

カウンター

パラメータ データ型 必須 説明
counterId string true カウンター
limitName string true 回数制限の種類の名前
name string true カウンターの名前
userId string false ユーザーID
count integer true カウント値
createdAt long true 作成日時
updatedAt long true 最終更新日時

LimitModelMaster

回数制限の種類マスター

記録する回数のバリエーション・リセットタイミングごとに種類を定義します。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
limitModelId string true 回数制限の種類マスター
name string true 回数制限の種類名
description string false 回数制限の種類マスターの説明
metadata string false 回数制限の種類のメタデータ
resetType string true リセットタイミング
resetDayOfMonth integer true リセットをする日にち
resetDayOfWeek string true リセットする曜日
resetHour integer true リセット時刻
createdAt long true 作成日時
updatedAt long true 最終更新日時

CurrentLimitMaster

現在有効な回数制限設定

エクスポートしたマスターデータを、現在有効な回数制限設定としてインポートして使用します。

パラメータ データ型 必須 説明
namespaceId string true 現在有効な回数制限設定
settings string true マスターデータ

ResponseCache

レスポンスキャッシュ

パラメータ データ型 必須 説明
region string false
ownerId string true オーナーID
responseCacheId string true レスポンスキャッシュ のGRN
requestHash string false
result string true APIの応答内容

GitHubCheckoutSetting

GitHubからリソースをチェックアウトしてくる設定

パラメータ データ型 必須 説明
apiKeyId string true リソースの取得に使用するGitHub のAPIキー のGRN
repositoryName string true リポジトリ名
sourcePath string true ソースコードのファイルパス
referenceType string true コードの取得元
commitHash string true コミットハッシュ
branchName string true ブランチ名
tagName string true タグ名

LogSetting

ロギング通知設定

パラメータ データ型 必須 説明
loggingNamespaceId string false ログの記録に使用する GS2-Log のネームスペース のGRN

LimitModel

回数制限の種類

記録する回数のバリエーション・リセットタイミングごとに種類を定義します。

パラメータ データ型 必須 説明
limitModelId string true 回数制限の種類
name string true 回数制限の種類名
metadata string false 回数制限の種類のメタデータ
resetType string true リセットタイミング
resetDayOfMonth integer true リセットをする日にち
resetDayOfWeek string true リセットする曜日
resetHour integer true リセット時刻

初期化処理

HTTPプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_limit_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2LimitRestClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.limit.rest.Gs2LimitRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)
session.connect()
Gs2LimitRestClient client = new Gs2LimitRestClient(session)
初期化処理は不要です

HTTPプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_limit_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2LimitRestClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.limit.rest.Gs2LimitRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2LimitRestClient client = new Gs2LimitRestClient(session)
    }
)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_limit_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2LimitWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.limit.webSocket.Gs2LimitWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect()
Gs2LimitWebSocketClient client = new Gs2LimitWebSocketClient(session)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_limit_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2LimitWebSocketClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.limit.webSocket.Gs2LimitWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2LimitWebSocketClient client = new Gs2LimitWebSocketClient(session)
    }
)
初期化処理は不要です

GS2-Limit は HTTPプロトコル と WebSocketプロトコル の2種類のプロトコルをサポートしています。

HTTPプロトコル と WebSocketプロトコル の違いは以下に示すとおりです。

HTTP WebSocket
接続方式 都度接続 常時接続
応答性能 優れている
API制限 なし 大容量のデータをやりとりするAPIには使用不可(主にマスターデータ系処理)
利用料金 WebSocketと同一 HTTPと同一

終了処理

HTTPプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

WebSocketプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

session オブジェクトの切断処理を行って終了処理を行います。 同一 session オブジェクトを複数の異なる Client オブジェクトに渡すことができます。

メソッド

countUpByStampTask

同期処理

from gs2_limit_client.request import CountUpByStampTaskRequest
from gs2_limit_client.result import CountUpByStampTaskResult

result = client.count_up_by_stamp_task(
    CountUpByStampTaskRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.CountUpByStampTaskRequest
import io.gs2.limit.result.CountUpByStampTaskResult

result = client.countUpByStampTask(
    CountUpByStampTaskRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import CountUpByStampTaskRequest
from gs2_limit_client.result import CountUpByStampTaskResult

def callback(async_result: AsyncResult[CountUpByStampTaskResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.count_up_by_stamp_task_async(
    CountUpByStampTaskRequest()\
    callback
)
import io.gs2.limit.request.CountUpByStampTaskRequest
import io.gs2.limit.result.CountUpByStampTaskResult

result = client.countUpByStampTask(
    CountUpByStampTaskRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタンプシートでカウントアップ

パラメータ データ型 必須 説明
stampTask string true スタンプタスク
keyId string true スタンプタスクの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Counter カウントを増やしたカウンター
newContextStack string スタンプタスクの実行結果を記録したコンテキスト

countUpByUserId

同期処理

from gs2_limit_client.request import CountUpByUserIdRequest
from gs2_limit_client.result import CountUpByUserIdResult

result = client.count_up_by_user_id(
    CountUpByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.CountUpByUserIdRequest
import io.gs2.limit.result.CountUpByUserIdResult

result = client.countUpByUserId(
    CountUpByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import CountUpByUserIdRequest
from gs2_limit_client.result import CountUpByUserIdResult

def callback(async_result: AsyncResult[CountUpByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.count_up_by_user_id_async(
    CountUpByUserIdRequest()\
    callback
)
import io.gs2.limit.request.CountUpByUserIdRequest
import io.gs2.limit.result.CountUpByUserIdResult

result = client.countUpByUserId(
    CountUpByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
limitName string true 回数制限の種類の名前
counterName string true カウンターの名前
userId string false ユーザーID
countUpValue integer false カウントアップする量
maxValue integer false カウントアップを許容する最大値 を入力してください
パラメータ データ型 説明
item Counter カウントを増やしたカウンター

createLimitModelMaster

同期処理

from gs2_limit_client.request import CreateLimitModelMasterRequest
from gs2_limit_client.result import CreateLimitModelMasterResult

result = client.create_limit_model_master(
    CreateLimitModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_name('limit-model-0001')\
        .with_reset_type('notReset')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.CreateLimitModelMasterRequest
import io.gs2.limit.result.CreateLimitModelMasterResult

result = client.createLimitModelMaster(
    CreateLimitModelMasterRequest()
        .withNamespaceName("category-0001")
        .withName("limit-model-0001")
        .withResetType("notReset")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import CreateLimitModelMasterRequest
from gs2_limit_client.result import CreateLimitModelMasterResult

def callback(async_result: AsyncResult[CreateLimitModelMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_limit_model_master_async(
    CreateLimitModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_name('limit-model-0001')\
        .with_reset_type('notReset'),
    callback
)
import io.gs2.limit.request.CreateLimitModelMasterRequest
import io.gs2.limit.result.CreateLimitModelMasterResult

result = client.createLimitModelMaster(
    CreateLimitModelMasterRequest()
        .withNamespaceName("category-0001")
        .withName("limit-model-0001")
        .withResetType("notReset"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Limit::LimitModelMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  ResetType: String
  ResetDayOfMonth: Integer
  ResetDayOfWeek: String
  ResetHour: Integer

回数制限の種類マスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true 回数制限の種類名
description string false 回数制限の種類マスターの説明
metadata string false 回数制限の種類のメタデータ
resetType string true リセットタイミング
resetDayOfMonth integer true リセットをする日にち
resetDayOfWeek string true リセットする曜日
resetHour integer true リセット時刻
パラメータ データ型 説明
item LimitModelMaster 作成した回数制限の種類マスター

createNamespace

同期処理

from gs2_limit_client.request import CreateNamespaceRequest
from gs2_limit_client.result import CreateNamespaceResult

result = client.create_namespace(
    CreateNamespaceRequest()\
        .with_name('category-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.CreateNamespaceRequest
import io.gs2.limit.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("category-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import CreateNamespaceRequest
from gs2_limit_client.result import CreateNamespaceResult

def callback(async_result: AsyncResult[CreateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_namespace_async(
    CreateNamespaceRequest()\
        .with_name('category-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.limit.request.CreateNamespaceRequest
import io.gs2.limit.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("category-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Limit::Namespace
Properties:
  Name: String
  Description: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

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

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false ネームスペースの説明
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

deleteByStampSheet

同期処理

from gs2_limit_client.request import DeleteByStampSheetRequest
from gs2_limit_client.result import DeleteByStampSheetResult

result = client.delete_by_stamp_sheet(
    DeleteByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.DeleteByStampSheetRequest
import io.gs2.limit.result.DeleteByStampSheetResult

result = client.deleteByStampSheet(
    DeleteByStampSheetRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import DeleteByStampSheetRequest
from gs2_limit_client.result import DeleteByStampSheetResult

def callback(async_result: AsyncResult[DeleteByStampSheetResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_by_stamp_sheet_async(
    DeleteByStampSheetRequest()\
    callback
)
import io.gs2.limit.request.DeleteByStampSheetRequest
import io.gs2.limit.result.DeleteByStampSheetResult

result = client.deleteByStampSheet(
    DeleteByStampSheetRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタンプシートでカウンターを削除

パラメータ データ型 必須 説明
stampSheet string true スタンプシート
keyId string true スタンプシートの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Counter カウンター

deleteCounterByUserId

同期処理

from gs2_limit_client.request import DeleteCounterByUserIdRequest
from gs2_limit_client.result import DeleteCounterByUserIdResult

result = client.delete_counter_by_user_id(
    DeleteCounterByUserIdRequest()\
        .with_namespace_name('category-0002')\
        .with_limit_name('limit-model-0001')\
        .with_user_id('user-0001')\
        .with_counter_name('counter1')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.DeleteCounterByUserIdRequest
import io.gs2.limit.result.DeleteCounterByUserIdResult

result = client.deleteCounterByUserId(
    DeleteCounterByUserIdRequest()
        .withNamespaceName("category-0002")
        .withLimitName("limit-model-0001")
        .withUserId("user-0001")
        .withCounterName("counter1")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import DeleteCounterByUserIdRequest
from gs2_limit_client.result import DeleteCounterByUserIdResult

def callback(async_result: AsyncResult[DeleteCounterByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_counter_by_user_id_async(
    DeleteCounterByUserIdRequest()\
        .with_namespace_name('category-0002')\
        .with_limit_name('limit-model-0001')\
        .with_user_id('user-0001')\
        .with_counter_name('counter1'),
    callback
)
import io.gs2.limit.request.DeleteCounterByUserIdRequest
import io.gs2.limit.result.DeleteCounterByUserIdResult

result = client.deleteCounterByUserId(
    DeleteCounterByUserIdRequest()
        .withNamespaceName("category-0002")
        .withLimitName("limit-model-0001")
        .withUserId("user-0001")
        .withCounterName("counter1"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
limitName string true 回数制限の種類の名前
userId string false ユーザーID
counterName string true カウンターの名前
パラメータ データ型 説明
item Counter カウンター

deleteLimitModelMaster

同期処理

from gs2_limit_client.request import DeleteLimitModelMasterRequest
from gs2_limit_client.result import DeleteLimitModelMasterResult

result = client.delete_limit_model_master(
    DeleteLimitModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_limit_name('limit-model-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.DeleteLimitModelMasterRequest
import io.gs2.limit.result.DeleteLimitModelMasterResult

result = client.deleteLimitModelMaster(
    DeleteLimitModelMasterRequest()
        .withNamespaceName("category-0001")
        .withLimitName("limit-model-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import DeleteLimitModelMasterRequest
from gs2_limit_client.result import DeleteLimitModelMasterResult

def callback(async_result: AsyncResult[DeleteLimitModelMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_limit_model_master_async(
    DeleteLimitModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_limit_name('limit-model-0001'),
    callback
)
import io.gs2.limit.request.DeleteLimitModelMasterRequest
import io.gs2.limit.result.DeleteLimitModelMasterResult

result = client.deleteLimitModelMaster(
    DeleteLimitModelMasterRequest()
        .withNamespaceName("category-0001")
        .withLimitName("limit-model-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

回数制限の種類マスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
limitName string true 回数制限の種類名
パラメータ データ型 説明
item LimitModelMaster 削除した回数制限の種類マスター

deleteNamespace

同期処理

from gs2_limit_client.request import DeleteNamespaceRequest
from gs2_limit_client.result import DeleteNamespaceResult

result = client.delete_namespace(
    DeleteNamespaceRequest()\
        .with_namespace_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.DeleteNamespaceRequest
import io.gs2.limit.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("category-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import DeleteNamespaceRequest
from gs2_limit_client.result import DeleteNamespaceResult

def callback(async_result: AsyncResult[DeleteNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_namespace_async(
    DeleteNamespaceRequest()\
        .with_namespace_name('category-0001'),
    callback
)
import io.gs2.limit.request.DeleteNamespaceRequest
import io.gs2.limit.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("category-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace 削除したネームスペース

describeCounters

同期処理

from gs2_limit_client.request import DescribeCountersRequest
from gs2_limit_client.result import DescribeCountersResult

result = client.describe_counters(
    DescribeCountersRequest()\
        .with_namespace_name('category-0002')\
        .with_limit_name('limit-model-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.DescribeCountersRequest
import io.gs2.limit.result.DescribeCountersResult

result = client.describeCounters(
    DescribeCountersRequest()
        .withNamespaceName("category-0002")
        .withLimitName("limit-model-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import DescribeCountersRequest
from gs2_limit_client.result import DescribeCountersResult

def callback(async_result: AsyncResult[DescribeCountersResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_counters_async(
    DescribeCountersRequest()\
        .with_namespace_name('category-0002')\
        .with_limit_name('limit-model-0001'),
    callback
)
import io.gs2.limit.request.DescribeCountersRequest
import io.gs2.limit.result.DescribeCountersResult

result = client.describeCounters(
    DescribeCountersRequest()
        .withNamespaceName("category-0002")
        .withLimitName("limit-model-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

カウンターの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
limitName string false 回数制限の種類の名前
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Counter] カウンターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeCountersByUserId

同期処理

from gs2_limit_client.request import DescribeCountersByUserIdRequest
from gs2_limit_client.result import DescribeCountersByUserIdResult

result = client.describe_counters_by_user_id(
    DescribeCountersByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.DescribeCountersByUserIdRequest
import io.gs2.limit.result.DescribeCountersByUserIdResult

result = client.describeCountersByUserId(
    DescribeCountersByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import DescribeCountersByUserIdRequest
from gs2_limit_client.result import DescribeCountersByUserIdResult

def callback(async_result: AsyncResult[DescribeCountersByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_counters_by_user_id_async(
    DescribeCountersByUserIdRequest()\
    callback
)
import io.gs2.limit.request.DescribeCountersByUserIdRequest
import io.gs2.limit.result.DescribeCountersByUserIdResult

result = client.describeCountersByUserId(
    DescribeCountersByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

カウンターの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
limitName string false 回数制限の種類の名前
userId string false ユーザーID
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Counter] カウンターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeLimitModelMasters

同期処理

from gs2_limit_client.request import DescribeLimitModelMastersRequest
from gs2_limit_client.result import DescribeLimitModelMastersResult

result = client.describe_limit_model_masters(
    DescribeLimitModelMastersRequest()\
        .with_namespace_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.DescribeLimitModelMastersRequest
import io.gs2.limit.result.DescribeLimitModelMastersResult

result = client.describeLimitModelMasters(
    DescribeLimitModelMastersRequest()
        .withNamespaceName("category-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import DescribeLimitModelMastersRequest
from gs2_limit_client.result import DescribeLimitModelMastersResult

def callback(async_result: AsyncResult[DescribeLimitModelMastersResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_limit_model_masters_async(
    DescribeLimitModelMastersRequest()\
        .with_namespace_name('category-0001'),
    callback
)
import io.gs2.limit.request.DescribeLimitModelMastersRequest
import io.gs2.limit.result.DescribeLimitModelMastersResult

result = client.describeLimitModelMasters(
    DescribeLimitModelMastersRequest()
        .withNamespaceName("category-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

回数制限の種類マスターの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[LimitModelMaster] 回数制限の種類マスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeLimitModels

同期処理

from gs2_limit_client.request import DescribeLimitModelsRequest
from gs2_limit_client.result import DescribeLimitModelsResult

result = client.describe_limit_models(
    DescribeLimitModelsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.DescribeLimitModelsRequest
import io.gs2.limit.result.DescribeLimitModelsResult

result = client.describeLimitModels(
    DescribeLimitModelsRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import DescribeLimitModelsRequest
from gs2_limit_client.result import DescribeLimitModelsResult

def callback(async_result: AsyncResult[DescribeLimitModelsResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_limit_models_async(
    DescribeLimitModelsRequest()\
    callback
)
import io.gs2.limit.request.DescribeLimitModelsRequest
import io.gs2.limit.result.DescribeLimitModelsResult

result = client.describeLimitModels(
    DescribeLimitModelsRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

回数制限の種類の一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[LimitModel] 回数制限の種類のリスト

describeNamespaces

同期処理

from gs2_limit_client.request import DescribeNamespacesRequest
from gs2_limit_client.result import DescribeNamespacesResult

result = client.describe_namespaces(
    DescribeNamespacesRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.DescribeNamespacesRequest
import io.gs2.limit.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import DescribeNamespacesRequest
from gs2_limit_client.result import DescribeNamespacesResult

def callback(async_result: AsyncResult[DescribeNamespacesResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_namespaces_async(
    DescribeNamespacesRequest()\
    callback
)
import io.gs2.limit.request.DescribeNamespacesRequest
import io.gs2.limit.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Namespace] ネームスペースのリスト
nextPageToken string リストの続きを取得するためのページトークン

exportMaster

同期処理

from gs2_limit_client.request import ExportMasterRequest
from gs2_limit_client.result import ExportMasterResult

result = client.export_master(
    ExportMasterRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.ExportMasterRequest
import io.gs2.limit.result.ExportMasterResult

result = client.exportMaster(
    ExportMasterRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import ExportMasterRequest
from gs2_limit_client.result import ExportMasterResult

def callback(async_result: AsyncResult[ExportMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.export_master_async(
    ExportMasterRequest()\
    callback
)
import io.gs2.limit.request.ExportMasterRequest
import io.gs2.limit.result.ExportMasterResult

result = client.exportMaster(
    ExportMasterRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentLimitMaster 現在有効な回数制限設定

getCounter

同期処理

from gs2_limit_client.request import GetCounterRequest
from gs2_limit_client.result import GetCounterResult

result = client.get_counter(
    GetCounterRequest()\
        .with_namespace_name('category-0002')\
        .with_limit_name('limit-model-0001')\
        .with_counter_name('counter2')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.GetCounterRequest
import io.gs2.limit.result.GetCounterResult

result = client.getCounter(
    GetCounterRequest()
        .withNamespaceName("category-0002")
        .withLimitName("limit-model-0001")
        .withCounterName("counter2")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import GetCounterRequest
from gs2_limit_client.result import GetCounterResult

def callback(async_result: AsyncResult[GetCounterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_counter_async(
    GetCounterRequest()\
        .with_namespace_name('category-0002')\
        .with_limit_name('limit-model-0001')\
        .with_counter_name('counter2'),
    callback
)
import io.gs2.limit.request.GetCounterRequest
import io.gs2.limit.result.GetCounterResult

result = client.getCounter(
    GetCounterRequest()
        .withNamespaceName("category-0002")
        .withLimitName("limit-model-0001")
        .withCounterName("counter2"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

カウンターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
limitName string true 回数制限の種類の名前
counterName string true カウンターの名前
パラメータ データ型 説明
item Counter カウンター

getCounterByUserId

同期処理

from gs2_limit_client.request import GetCounterByUserIdRequest
from gs2_limit_client.result import GetCounterByUserIdResult

result = client.get_counter_by_user_id(
    GetCounterByUserIdRequest()\
        .with_namespace_name('category-0001')\
        .with_limit_name('limit-model-0001')\
        .with_user_id('user-0001')\
        .with_counter_name('counter3')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.GetCounterByUserIdRequest
import io.gs2.limit.result.GetCounterByUserIdResult

result = client.getCounterByUserId(
    GetCounterByUserIdRequest()
        .withNamespaceName("category-0001")
        .withLimitName("limit-model-0001")
        .withUserId("user-0001")
        .withCounterName("counter3")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import GetCounterByUserIdRequest
from gs2_limit_client.result import GetCounterByUserIdResult

def callback(async_result: AsyncResult[GetCounterByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_counter_by_user_id_async(
    GetCounterByUserIdRequest()\
        .with_namespace_name('category-0001')\
        .with_limit_name('limit-model-0001')\
        .with_user_id('user-0001')\
        .with_counter_name('counter3'),
    callback
)
import io.gs2.limit.request.GetCounterByUserIdRequest
import io.gs2.limit.result.GetCounterByUserIdResult

result = client.getCounterByUserId(
    GetCounterByUserIdRequest()
        .withNamespaceName("category-0001")
        .withLimitName("limit-model-0001")
        .withUserId("user-0001")
        .withCounterName("counter3"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
limitName string true 回数制限の種類の名前
userId string false ユーザーID
counterName string true カウンターの名前
パラメータ データ型 説明
item Counter カウンター

getCurrentLimitMaster

同期処理

from gs2_limit_client.request import GetCurrentLimitMasterRequest
from gs2_limit_client.result import GetCurrentLimitMasterResult

result = client.get_current_limit_master(
    GetCurrentLimitMasterRequest()\
        .with_namespace_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.GetCurrentLimitMasterRequest
import io.gs2.limit.result.GetCurrentLimitMasterResult

result = client.getCurrentLimitMaster(
    GetCurrentLimitMasterRequest()
        .withNamespaceName("category-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import GetCurrentLimitMasterRequest
from gs2_limit_client.result import GetCurrentLimitMasterResult

def callback(async_result: AsyncResult[GetCurrentLimitMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_current_limit_master_async(
    GetCurrentLimitMasterRequest()\
        .with_namespace_name('category-0001'),
    callback
)
import io.gs2.limit.request.GetCurrentLimitMasterRequest
import io.gs2.limit.result.GetCurrentLimitMasterResult

result = client.getCurrentLimitMaster(
    GetCurrentLimitMasterRequest()
        .withNamespaceName("category-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentLimitMaster 現在有効な回数制限設定

getLimitModel

同期処理

from gs2_limit_client.request import GetLimitModelRequest
from gs2_limit_client.result import GetLimitModelResult

result = client.get_limit_model(
    GetLimitModelRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.GetLimitModelRequest
import io.gs2.limit.result.GetLimitModelResult

result = client.getLimitModel(
    GetLimitModelRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import GetLimitModelRequest
from gs2_limit_client.result import GetLimitModelResult

def callback(async_result: AsyncResult[GetLimitModelResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_limit_model_async(
    GetLimitModelRequest()\
    callback
)
import io.gs2.limit.request.GetLimitModelRequest
import io.gs2.limit.result.GetLimitModelResult

result = client.getLimitModel(
    GetLimitModelRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

回数制限の種類を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
limitName string true 回数制限の種類名
パラメータ データ型 説明
item LimitModel 回数制限の種類

getLimitModelMaster

同期処理

from gs2_limit_client.request import GetLimitModelMasterRequest
from gs2_limit_client.result import GetLimitModelMasterResult

result = client.get_limit_model_master(
    GetLimitModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_limit_name('limit-model-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.GetLimitModelMasterRequest
import io.gs2.limit.result.GetLimitModelMasterResult

result = client.getLimitModelMaster(
    GetLimitModelMasterRequest()
        .withNamespaceName("category-0001")
        .withLimitName("limit-model-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import GetLimitModelMasterRequest
from gs2_limit_client.result import GetLimitModelMasterResult

def callback(async_result: AsyncResult[GetLimitModelMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_limit_model_master_async(
    GetLimitModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_limit_name('limit-model-0001'),
    callback
)
import io.gs2.limit.request.GetLimitModelMasterRequest
import io.gs2.limit.result.GetLimitModelMasterResult

result = client.getLimitModelMaster(
    GetLimitModelMasterRequest()
        .withNamespaceName("category-0001")
        .withLimitName("limit-model-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

回数制限の種類マスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
limitName string true 回数制限の種類名
パラメータ データ型 説明
item LimitModelMaster 回数制限の種類マスター

getNamespace

同期処理

from gs2_limit_client.request import GetNamespaceRequest
from gs2_limit_client.result import GetNamespaceResult

result = client.get_namespace(
    GetNamespaceRequest()\
        .with_namespace_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.GetNamespaceRequest
import io.gs2.limit.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("category-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import GetNamespaceRequest
from gs2_limit_client.result import GetNamespaceResult

def callback(async_result: AsyncResult[GetNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_async(
    GetNamespaceRequest()\
        .with_namespace_name('category-0001'),
    callback
)
import io.gs2.limit.request.GetNamespaceRequest
import io.gs2.limit.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("category-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace ネームスペース

getNamespaceStatus

同期処理

from gs2_limit_client.request import GetNamespaceStatusRequest
from gs2_limit_client.result import GetNamespaceStatusResult

result = client.get_namespace_status(
    GetNamespaceStatusRequest()\
        .with_namespace_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.GetNamespaceStatusRequest
import io.gs2.limit.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest()
        .withNamespaceName("category-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import GetNamespaceStatusRequest
from gs2_limit_client.result import GetNamespaceStatusResult

def callback(async_result: AsyncResult[GetNamespaceStatusResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_status_async(
    GetNamespaceStatusRequest()\
        .with_namespace_name('category-0001'),
    callback
)
import io.gs2.limit.request.GetNamespaceStatusRequest
import io.gs2.limit.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest()
        .withNamespaceName("category-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
status string

updateCurrentLimitMaster

同期処理

from gs2_limit_client.request import UpdateCurrentLimitMasterRequest
from gs2_limit_client.result import UpdateCurrentLimitMasterResult

result = client.update_current_limit_master(
    UpdateCurrentLimitMasterRequest()\
        .with_namespace_name('category-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}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.UpdateCurrentLimitMasterRequest
import io.gs2.limit.result.UpdateCurrentLimitMasterResult

result = client.updateCurrentLimitMaster(
    UpdateCurrentLimitMasterRequest()
        .withNamespaceName("category-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}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import UpdateCurrentLimitMasterRequest
from gs2_limit_client.result import UpdateCurrentLimitMasterResult

def callback(async_result: AsyncResult[UpdateCurrentLimitMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_current_limit_master_async(
    UpdateCurrentLimitMasterRequest()\
        .with_namespace_name('category-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}'),
    callback
)
import io.gs2.limit.request.UpdateCurrentLimitMasterRequest
import io.gs2.limit.result.UpdateCurrentLimitMasterResult

result = client.updateCurrentLimitMaster(
    UpdateCurrentLimitMasterRequest()
        .withNamespaceName("category-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}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Limit::CurrentLimitMaster
Properties:
  NamespaceName: String
  Settings: String

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
settings string true マスターデータ
パラメータ データ型 説明
item CurrentLimitMaster 更新した現在有効な回数制限設定

updateCurrentLimitMasterFromGitHub

同期処理

from gs2_limit_client.request import UpdateCurrentLimitMasterFromGitHubRequest
from gs2_limit_client.result import UpdateCurrentLimitMasterFromGitHubResult

result = client.update_current_limit_master_from_git_hub(
    UpdateCurrentLimitMasterFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.UpdateCurrentLimitMasterFromGitHubRequest
import io.gs2.limit.result.UpdateCurrentLimitMasterFromGitHubResult

result = client.updateCurrentLimitMasterFromGitHub(
    UpdateCurrentLimitMasterFromGitHubRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import UpdateCurrentLimitMasterFromGitHubRequest
from gs2_limit_client.result import UpdateCurrentLimitMasterFromGitHubResult

def callback(async_result: AsyncResult[UpdateCurrentLimitMasterFromGitHubResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_current_limit_master_from_git_hub_async(
    UpdateCurrentLimitMasterFromGitHubRequest()\
    callback
)
import io.gs2.limit.request.UpdateCurrentLimitMasterFromGitHubRequest
import io.gs2.limit.result.UpdateCurrentLimitMasterFromGitHubResult

result = client.updateCurrentLimitMasterFromGitHub(
    UpdateCurrentLimitMasterFromGitHubRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
checkoutSetting GitHubCheckoutSetting true GitHubからマスターデータをチェックアウトしてくる設定
パラメータ データ型 説明
item CurrentLimitMaster 更新した現在有効な回数制限設定

updateLimitModelMaster

同期処理

from gs2_limit_client.request import UpdateLimitModelMasterRequest
from gs2_limit_client.result import UpdateLimitModelMasterResult

result = client.update_limit_model_master(
    UpdateLimitModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_limit_name('limit-model-0001')\
        .with_description('description1')\
        .with_metadata('{"hoge": "fuga"}')\
        .with_reset_type('daily')\
        .with_reset_hour(18)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.UpdateLimitModelMasterRequest
import io.gs2.limit.result.UpdateLimitModelMasterResult

result = client.updateLimitModelMaster(
    UpdateLimitModelMasterRequest()
        .withNamespaceName("category-0001")
        .withLimitName("limit-model-0001")
        .withDescription("description1")
        .withMetadata("{"hoge": "fuga"}")
        .withResetType("daily")
        .withResetHour(18)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import UpdateLimitModelMasterRequest
from gs2_limit_client.result import UpdateLimitModelMasterResult

def callback(async_result: AsyncResult[UpdateLimitModelMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_limit_model_master_async(
    UpdateLimitModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_limit_name('limit-model-0001')\
        .with_description('description1')\
        .with_metadata('{"hoge": "fuga"}')\
        .with_reset_type('daily')\
        .with_reset_hour(18),
    callback
)
import io.gs2.limit.request.UpdateLimitModelMasterRequest
import io.gs2.limit.result.UpdateLimitModelMasterResult

result = client.updateLimitModelMaster(
    UpdateLimitModelMasterRequest()
        .withNamespaceName("category-0001")
        .withLimitName("limit-model-0001")
        .withDescription("description1")
        .withMetadata("{"hoge": "fuga"}")
        .withResetType("daily")
        .withResetHour(18),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

回数制限の種類マスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
limitName string true 回数制限の種類名
description string false 回数制限の種類マスターの説明
metadata string false 回数制限の種類のメタデータ
resetType string true リセットタイミング
resetDayOfMonth integer true リセットをする日にち
resetDayOfWeek string true リセットする曜日
resetHour integer true リセット時刻
パラメータ データ型 説明
item LimitModelMaster 更新した回数制限の種類マスター

updateNamespace

同期処理

from gs2_limit_client.request import UpdateNamespaceRequest
from gs2_limit_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('category-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.limit.request.UpdateNamespaceRequest
import io.gs2.limit.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("category-0001")
        .withDescription("description1")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_limit_client.request import UpdateNamespaceRequest
from gs2_limit_client.result import UpdateNamespaceResult

def callback(async_result: AsyncResult[UpdateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_namespace_async(
    UpdateNamespaceRequest()\
        .with_namespace_name('category-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.limit.request.UpdateNamespaceRequest
import io.gs2.limit.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("category-0001")
        .withDescription("description1")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
description string false ネームスペースの説明
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

GS2-Script トリガーイベント

GS2-Limit が提供するスクリプトトリガーはありません

マスターデータフォーマット

CurrentLimitMaster

{
  "version": "2019-04-05"
  "limitModels": [
    {
      "name": "[string] 回数制限の種類名",
      "metadata": "[string] 回数制限の種類のメタデータ",
      "resetType": "[string] リセットタイミング",
      "resetDayOfMonth": "[integer] リセットをする日にち",
      "resetDayOfWeek": "[string] リセットする曜日",
      "resetHour": "[integer] リセット時刻"
    }
  ]
}

現在有効な回数制限設定

エクスポートしたマスターデータを、現在有効な回数制限設定としてインポートして使用します。

GS2-Limit の制限・制約

利用いただくにあたって注意いただく制限・制約はありません