NAV Navbar
Python Java GS2-Formation
 

GS2-Ranking

スコアやクリアタイムのランキング処理を実現します。

ランキングには全員が同じデータを参照するグローバルランキングと、 フレンド間やギルド内のランキングのようなユーザによって見えるランキングの内容の異なるスコープドランキングがあります。

グローバルランキングは、15分~24時間の間で指定した間隔でランキングの集計処理がおこなわれ、 ゲームユーザーからのリクエストは事前に集計された結果を応答します。 これによって、大量のゲームプレイヤーが居たとしてもレスポンスタイムは変わらないように設計されています。

スコープドランキングは各ゲームプレイヤーがスコアバケットをもち、購読しているゲームプレイヤーがスコアを登録するとスコアバケットにスコアが追加されます。 各ゲームプレイヤーは自分のスコアバケット内のスコアを使ってランキングを処理します。

グローバルランキング・スコープドランキング ともにユーザーID毎に保持できるスコアを1個にするか、複数保持できるかを設定できます。 ランキングを登録したときに最後に登録したスコアだけをランキング対象としたいか、登録したすべてのスコアをランキング対象としたいかで設定できます。 すべてのスコアをランキング対象とする場合、データ量が膨れ上がりやすくなります。その結果、GS2の利用料金にも影響を与えることとなります。 ゲームシステム上の大きな理由がなければ最後に登録された1つのスコアのみがランキング対象となるように設定することをお勧めします。

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

利用料金

グローバルランキング

集計処理1回につき、ランキング対象スコア1万件あたり 2円

スコープドランキング

スコア登録1回につき、スコアの購読数10件あたり 0.01円

モデル

Namespace

ネームスペース

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

CategoryModel

カテゴリ

ランキングのゲームモードなどを指定します

パラメータ データ型 必須 説明
categoryModelId string true カテゴリ
name string true カテゴリ名
metadata string false カテゴリのメタデータ
minimumValue long false スコアの最小値
maximumValue long false スコアの最大値
orderDirection string true スコアのソート方向
scope string true ランキングの種類
uniqueByUserId boolean true ユーザID毎にスコアを1つしか登録されないようにする
calculateIntervalMinutes integer true スコアの集計間隔(分)

CategoryModelMaster

カテゴリマスター

ランキングのゲームモードなどを指定します

パラメータ データ型 必須 説明
categoryModelId string true カテゴリマスター
name string true カテゴリモデル名
description string false カテゴリマスターの説明
metadata string false カテゴリマスターのメタデータ
minimumValue long false スコアの最小値
maximumValue long false スコアの最大値
orderDirection string true スコアのソート方向
scope string true ランキングの種類
uniqueByUserId boolean true ユーザID毎にスコアを1つしか登録されないようにする
calculateIntervalMinutes integer true スコアの集計間隔(分)
createdAt long true 作成日時
updatedAt long true 最終更新日時

Subscribe

購読

スコープランキングに反映してほしい他のプレイヤーを登録します。

パラメータ データ型 必須 説明
subscribeId string true 購読
categoryName string true カテゴリ名
userId string true 購読するユーザID
targetUserIds list[string] true 購読されるユーザIDリスト
createdAt long true 作成日時

Score

スコア

パラメータ データ型 必須 説明
scoreId string true スコア
categoryName string true カテゴリ名
userId string true ユーザID
uniqueId string true スコアのユニークID
scorerUserId string true スコアを獲得したユーザID
score long true スコア
metadata string false メタデータ
createdAt long true 作成日時

Ranking

ランキング

パラメータ データ型 必須 説明
rank long true 順位
index long true 1位からのインデックス
userId string true ユーザID
score long true スコア
metadata string false メタデータ
createdAt long true 作成日時

ResponseCache

レスポンスキャッシュ

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

CurrentRankingMaster

現在有効なランキング設定

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

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
settings string true マスターデータ

CalculatedAt

集計日時

パラメータ データ型 必須 説明
categoryName string false カテゴリ名
calculatedAt long true 集計日時

SubscribeUser

購読対象

パラメータ データ型 必須 説明
categoryName string true カテゴリ名
userId string true 購読するユーザID
targetUserId string true 購読されるユーザID

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

初期化処理

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

import gs2_core_client.model.*
import gs2_ranking_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_ranking_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 = Gs2RankingRestClient(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.ranking.rest.Gs2RankingRestClient

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

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

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

import gs2_core_client.model.*
import gs2_ranking_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 = Gs2RankingWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.ranking.webSocket.Gs2RankingWebSocketClient

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

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

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

import gs2_core_client.model.*
import gs2_ranking_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 = Gs2RankingWebSocketClient(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.ranking.webSocket.Gs2RankingWebSocketClient

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

createCategoryModelMaster

同期処理

from gs2_ranking_client.request import CreateCategoryModelMasterRequest
from gs2_ranking_client.result import CreateCategoryModelMasterResult

result = client.create_category_model_master(
    CreateCategoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('category-0001')\
        .with_order_direction('asc')\
        .with_scope('global')\
        .with_unique_by_user_id(False)\
        .with_calculate_interval_minutes(15)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.CreateCategoryModelMasterRequest
import io.gs2.ranking.result.CreateCategoryModelMasterResult

result = client.createCategoryModelMaster(
    CreateCategoryModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("category-0001")
        .withOrderDirection("asc")
        .withScope("global")
        .withUniqueByUserId(false)
        .withCalculateIntervalMinutes(15)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_ranking_client.request import CreateCategoryModelMasterRequest
from gs2_ranking_client.result import CreateCategoryModelMasterResult

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

result = client.create_category_model_master_async(
    CreateCategoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('category-0001')\
        .with_order_direction('asc')\
        .with_scope('global')\
        .with_unique_by_user_id(False)\
        .with_calculate_interval_minutes(15),
    callback
)
import io.gs2.ranking.request.CreateCategoryModelMasterRequest
import io.gs2.ranking.result.CreateCategoryModelMasterResult

result = client.createCategoryModelMaster(
    CreateCategoryModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("category-0001")
        .withOrderDirection("asc")
        .withScope("global")
        .withUniqueByUserId(false)
        .withCalculateIntervalMinutes(15),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Ranking::CategoryModelMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  MinimumValue: Optional[Long]
  MaximumValue: Optional[Long]
  OrderDirection: String
  Scope: String
  UniqueByUserId: Bool
  CalculateIntervalMinutes: Integer

カテゴリマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true カテゴリモデル名
description string false カテゴリマスターの説明
metadata string false カテゴリマスターのメタデータ
minimumValue long false スコアの最小値
maximumValue long false スコアの最大値
orderDirection string true スコアのソート方向
scope string true ランキングの種類
uniqueByUserId boolean true ユーザID毎にスコアを1つしか登録されないようにする
calculateIntervalMinutes integer true スコアの集計間隔(分)
パラメータ データ型 説明
item CategoryModelMaster 作成したカテゴリマスター

createNamespace

同期処理

from gs2_ranking_client.request import CreateNamespaceRequest
from gs2_ranking_client.result import CreateNamespaceResult

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

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

非同期処理

from gs2_ranking_client.request import CreateNamespaceRequest
from gs2_ranking_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('namespace-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.ranking.request.CreateNamespaceRequest
import io.gs2.ranking.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-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::Ranking::Namespace
Properties:
  Name: String
  Description: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

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

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

deleteCategoryModelMaster

同期処理

from gs2_ranking_client.request import DeleteCategoryModelMasterRequest
from gs2_ranking_client.result import DeleteCategoryModelMasterResult

result = client.delete_category_model_master(
    DeleteCategoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.DeleteCategoryModelMasterRequest
import io.gs2.ranking.result.DeleteCategoryModelMasterResult

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

非同期処理

from gs2_ranking_client.request import DeleteCategoryModelMasterRequest
from gs2_ranking_client.result import DeleteCategoryModelMasterResult

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

result = client.delete_category_model_master_async(
    DeleteCategoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001'),
    callback
)
import io.gs2.ranking.request.DeleteCategoryModelMasterRequest
import io.gs2.ranking.result.DeleteCategoryModelMasterResult

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

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

カテゴリマスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリモデル名
パラメータ データ型 説明
item CategoryModelMaster 削除したカテゴリマスター

deleteNamespace

同期処理

from gs2_ranking_client.request import DeleteNamespaceRequest
from gs2_ranking_client.result import DeleteNamespaceResult

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

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

非同期処理

from gs2_ranking_client.request import DeleteNamespaceRequest
from gs2_ranking_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('namespace-0001'),
    callback
)
import io.gs2.ranking.request.DeleteNamespaceRequest
import io.gs2.ranking.result.DeleteNamespaceResult

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

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

ネームスペースを削除

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

describeCategoryModelMasters

同期処理

from gs2_ranking_client.request import DescribeCategoryModelMastersRequest
from gs2_ranking_client.result import DescribeCategoryModelMastersResult

result = client.describe_category_model_masters(
    DescribeCategoryModelMastersRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.DescribeCategoryModelMastersRequest
import io.gs2.ranking.result.DescribeCategoryModelMastersResult

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

非同期処理

from gs2_ranking_client.request import DescribeCategoryModelMastersRequest
from gs2_ranking_client.result import DescribeCategoryModelMastersResult

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

result = client.describe_category_model_masters_async(
    DescribeCategoryModelMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.ranking.request.DescribeCategoryModelMastersRequest
import io.gs2.ranking.result.DescribeCategoryModelMastersResult

result = client.describeCategoryModelMasters(
    DescribeCategoryModelMastersRequest()
        .withNamespaceName("namespace-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[CategoryModelMaster] カテゴリマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeCategoryModels

同期処理

from gs2_ranking_client.request import DescribeCategoryModelsRequest
from gs2_ranking_client.result import DescribeCategoryModelsResult

result = client.describe_category_models(
    DescribeCategoryModelsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.DescribeCategoryModelsRequest
import io.gs2.ranking.result.DescribeCategoryModelsResult

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

非同期処理

from gs2_ranking_client.request import DescribeCategoryModelsRequest
from gs2_ranking_client.result import DescribeCategoryModelsResult

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

result = client.describe_category_models_async(
    DescribeCategoryModelsRequest()\
    callback
)
import io.gs2.ranking.request.DescribeCategoryModelsRequest
import io.gs2.ranking.result.DescribeCategoryModelsResult

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

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

カテゴリの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[CategoryModel] カテゴリのリスト

describeNamespaces

同期処理

from gs2_ranking_client.request import DescribeNamespacesRequest
from gs2_ranking_client.result import DescribeNamespacesResult

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

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

非同期処理

from gs2_ranking_client.request import DescribeNamespacesRequest
from gs2_ranking_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.ranking.request.DescribeNamespacesRequest
import io.gs2.ranking.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 リストの続きを取得するためのページトークン

describeNearRankings

同期処理

from gs2_ranking_client.request import DescribeNearRankingsRequest
from gs2_ranking_client.result import DescribeNearRankingsResult

result = client.describe_near_rankings(
    DescribeNearRankingsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.DescribeNearRankingsRequest
import io.gs2.ranking.result.DescribeNearRankingsResult

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

非同期処理

from gs2_ranking_client.request import DescribeNearRankingsRequest
from gs2_ranking_client.result import DescribeNearRankingsResult

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

result = client.describe_near_rankings_async(
    DescribeNearRankingsRequest()\
    callback
)
import io.gs2.ranking.request.DescribeNearRankingsRequest
import io.gs2.ranking.result.DescribeNearRankingsResult

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

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

指定したスコア付近のランキングを取得

このAPIはグローバルランキングのときのみ使用できます

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
score long true スコア
パラメータ データ型 説明
items list[Ranking] ランキングのリスト

describeRankings

同期処理

from gs2_ranking_client.request import DescribeRankingsRequest
from gs2_ranking_client.result import DescribeRankingsResult

result = client.describe_rankings(
    DescribeRankingsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.DescribeRankingsRequest
import io.gs2.ranking.result.DescribeRankingsResult

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

非同期処理

from gs2_ranking_client.request import DescribeRankingsRequest
from gs2_ranking_client.result import DescribeRankingsResult

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

result = client.describe_rankings_async(
    DescribeRankingsRequest()\
    callback
)
import io.gs2.ranking.request.DescribeRankingsRequest
import io.gs2.ranking.result.DescribeRankingsResult

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

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

ランキングを取得

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

describeRankingssByUserId

同期処理

from gs2_ranking_client.request import DescribeRankingssByUserIdRequest
from gs2_ranking_client.result import DescribeRankingssByUserIdResult

result = client.describe_rankingss_by_user_id(
    DescribeRankingssByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.DescribeRankingssByUserIdRequest
import io.gs2.ranking.result.DescribeRankingssByUserIdResult

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

非同期処理

from gs2_ranking_client.request import DescribeRankingssByUserIdRequest
from gs2_ranking_client.result import DescribeRankingssByUserIdResult

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

result = client.describe_rankingss_by_user_id_async(
    DescribeRankingssByUserIdRequest()\
    callback
)
import io.gs2.ranking.request.DescribeRankingssByUserIdRequest
import io.gs2.ranking.result.DescribeRankingssByUserIdResult

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

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

ユーザIDを指定してランキングを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
userId string true ユーザID
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Ranking] ランキングのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeSubscribesByCategoryName

同期処理

from gs2_ranking_client.request import DescribeSubscribesByCategoryNameRequest
from gs2_ranking_client.result import DescribeSubscribesByCategoryNameResult

result = client.describe_subscribes_by_category_name(
    DescribeSubscribesByCategoryNameRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.DescribeSubscribesByCategoryNameRequest
import io.gs2.ranking.result.DescribeSubscribesByCategoryNameResult

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

非同期処理

from gs2_ranking_client.request import DescribeSubscribesByCategoryNameRequest
from gs2_ranking_client.result import DescribeSubscribesByCategoryNameResult

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

result = client.describe_subscribes_by_category_name_async(
    DescribeSubscribesByCategoryNameRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001'),
    callback
)
import io.gs2.ranking.request.DescribeSubscribesByCategoryNameRequest
import io.gs2.ranking.result.DescribeSubscribesByCategoryNameResult

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

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

購読しているユーザIDの一覧取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
パラメータ データ型 説明
items list[SubscribeUser] 購読対象のリスト

describeSubscribesByCategoryNameAndUserId

同期処理

from gs2_ranking_client.request import DescribeSubscribesByCategoryNameAndUserIdRequest
from gs2_ranking_client.result import DescribeSubscribesByCategoryNameAndUserIdResult

result = client.describe_subscribes_by_category_name_and_user_id(
    DescribeSubscribesByCategoryNameAndUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.DescribeSubscribesByCategoryNameAndUserIdRequest
import io.gs2.ranking.result.DescribeSubscribesByCategoryNameAndUserIdResult

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

非同期処理

from gs2_ranking_client.request import DescribeSubscribesByCategoryNameAndUserIdRequest
from gs2_ranking_client.result import DescribeSubscribesByCategoryNameAndUserIdResult

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

result = client.describe_subscribes_by_category_name_and_user_id_async(
    DescribeSubscribesByCategoryNameAndUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.ranking.request.DescribeSubscribesByCategoryNameAndUserIdRequest
import io.gs2.ranking.result.DescribeSubscribesByCategoryNameAndUserIdResult

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

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

ユーザIDを指定して購読しているユーザIDの一覧取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
userId string true 購読するユーザID
パラメータ データ型 説明
items list[SubscribeUser] 購読対象のリスト

exportMaster

同期処理

from gs2_ranking_client.request import ExportMasterRequest
from gs2_ranking_client.result import ExportMasterResult

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

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

非同期処理

from gs2_ranking_client.request import ExportMasterRequest
from gs2_ranking_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.ranking.request.ExportMasterRequest
import io.gs2.ranking.result.ExportMasterResult

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

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

現在有効なランキング設定のマスターデータをエクスポートします

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentRankingMaster 現在有効なランキング設定

getCategoryModel

同期処理

from gs2_ranking_client.request import GetCategoryModelRequest
from gs2_ranking_client.result import GetCategoryModelResult

result = client.get_category_model(
    GetCategoryModelRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.GetCategoryModelRequest
import io.gs2.ranking.result.GetCategoryModelResult

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

非同期処理

from gs2_ranking_client.request import GetCategoryModelRequest
from gs2_ranking_client.result import GetCategoryModelResult

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

result = client.get_category_model_async(
    GetCategoryModelRequest()\
    callback
)
import io.gs2.ranking.request.GetCategoryModelRequest
import io.gs2.ranking.result.GetCategoryModelResult

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

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

カテゴリを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリモデル名
パラメータ データ型 説明
item CategoryModel カテゴリ

getCategoryModelMaster

同期処理

from gs2_ranking_client.request import GetCategoryModelMasterRequest
from gs2_ranking_client.result import GetCategoryModelMasterResult

result = client.get_category_model_master(
    GetCategoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.GetCategoryModelMasterRequest
import io.gs2.ranking.result.GetCategoryModelMasterResult

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

非同期処理

from gs2_ranking_client.request import GetCategoryModelMasterRequest
from gs2_ranking_client.result import GetCategoryModelMasterResult

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

result = client.get_category_model_master_async(
    GetCategoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001'),
    callback
)
import io.gs2.ranking.request.GetCategoryModelMasterRequest
import io.gs2.ranking.result.GetCategoryModelMasterResult

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

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

カテゴリマスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリモデル名
パラメータ データ型 説明
item CategoryModelMaster カテゴリマスター

getCurrentRankingMaster

同期処理

from gs2_ranking_client.request import GetCurrentRankingMasterRequest
from gs2_ranking_client.result import GetCurrentRankingMasterResult

result = client.get_current_ranking_master(
    GetCurrentRankingMasterRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.GetCurrentRankingMasterRequest
import io.gs2.ranking.result.GetCurrentRankingMasterResult

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

非同期処理

from gs2_ranking_client.request import GetCurrentRankingMasterRequest
from gs2_ranking_client.result import GetCurrentRankingMasterResult

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

result = client.get_current_ranking_master_async(
    GetCurrentRankingMasterRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.ranking.request.GetCurrentRankingMasterRequest
import io.gs2.ranking.result.GetCurrentRankingMasterResult

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

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

現在有効なランキング設定を取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentRankingMaster 現在有効なランキング設定

getNamespace

同期処理

from gs2_ranking_client.request import GetNamespaceRequest
from gs2_ranking_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_ranking_client.request import GetNamespaceRequest
from gs2_ranking_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('namespace-0001'),
    callback
)
import io.gs2.ranking.request.GetNamespaceRequest
import io.gs2.ranking.result.GetNamespaceResult

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

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

ネームスペースを取得

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

getNamespaceStatus

同期処理

from gs2_ranking_client.request import GetNamespaceStatusRequest
from gs2_ranking_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_ranking_client.request import GetNamespaceStatusRequest
from gs2_ranking_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('namespace-0001'),
    callback
)
import io.gs2.ranking.request.GetNamespaceStatusRequest
import io.gs2.ranking.result.GetNamespaceStatusResult

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

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

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

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

getSubscribe

同期処理

from gs2_ranking_client.request import GetSubscribeRequest
from gs2_ranking_client.result import GetSubscribeResult

result = client.get_subscribe(
    GetSubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')\
        .with_target_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.GetSubscribeRequest
import io.gs2.ranking.result.GetSubscribeResult

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

非同期処理

from gs2_ranking_client.request import GetSubscribeRequest
from gs2_ranking_client.result import GetSubscribeResult

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

result = client.get_subscribe_async(
    GetSubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')\
        .with_target_user_id('user-0002'),
    callback
)
import io.gs2.ranking.request.GetSubscribeRequest
import io.gs2.ranking.result.GetSubscribeResult

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

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

購読を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
targetUserId string true 購読されるユーザID
パラメータ データ型 説明
item SubscribeUser 購読対象

getSubscribeByUserId

同期処理

from gs2_ranking_client.request import GetSubscribeByUserIdRequest
from gs2_ranking_client.result import GetSubscribeByUserIdResult

result = client.get_subscribe_by_user_id(
    GetSubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0002')\
        .with_user_id('user-0001')\
        .with_target_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.GetSubscribeByUserIdRequest
import io.gs2.ranking.result.GetSubscribeByUserIdResult

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

非同期処理

from gs2_ranking_client.request import GetSubscribeByUserIdRequest
from gs2_ranking_client.result import GetSubscribeByUserIdResult

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

result = client.get_subscribe_by_user_id_async(
    GetSubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0002')\
        .with_user_id('user-0001')\
        .with_target_user_id('user-0001'),
    callback
)
import io.gs2.ranking.request.GetSubscribeByUserIdRequest
import io.gs2.ranking.result.GetSubscribeByUserIdResult

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

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

ユーザIDを指定して購読を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
userId string true 購読するユーザID
targetUserId string true 購読されるユーザID
パラメータ データ型 説明
item SubscribeUser 購読対象

putScore

同期処理

from gs2_ranking_client.request import PutScoreRequest
from gs2_ranking_client.result import PutScoreResult

result = client.put_score(
    PutScoreRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.PutScoreRequest
import io.gs2.ranking.result.PutScoreResult

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

非同期処理

from gs2_ranking_client.request import PutScoreRequest
from gs2_ranking_client.result import PutScoreResult

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

result = client.put_score_async(
    PutScoreRequest()\
    callback
)
import io.gs2.ranking.request.PutScoreRequest
import io.gs2.ranking.result.PutScoreResult

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

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

スコアを登録

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
score long true スコア
metadata string false メタデータ
パラメータ データ型 説明
item Score 登録したスコア

putScoreByUserId

同期処理

from gs2_ranking_client.request import PutScoreByUserIdRequest
from gs2_ranking_client.result import PutScoreByUserIdResult

result = client.put_score_by_user_id(
    PutScoreByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.PutScoreByUserIdRequest
import io.gs2.ranking.result.PutScoreByUserIdResult

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

非同期処理

from gs2_ranking_client.request import PutScoreByUserIdRequest
from gs2_ranking_client.result import PutScoreByUserIdResult

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

result = client.put_score_by_user_id_async(
    PutScoreByUserIdRequest()\
    callback
)
import io.gs2.ranking.request.PutScoreByUserIdRequest
import io.gs2.ranking.result.PutScoreByUserIdResult

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

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

ユーザーIDを指定してスコアを登録

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
userId string true ユーザID
score long true スコア
metadata string false メタデータ
パラメータ データ型 説明
item Score 登録したスコア

subscribe

同期処理

from gs2_ranking_client.request import SubscribeRequest
from gs2_ranking_client.result import SubscribeResult

result = client.subscribe(
    SubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')\
        .with_target_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.SubscribeRequest
import io.gs2.ranking.result.SubscribeResult

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

非同期処理

from gs2_ranking_client.request import SubscribeRequest
from gs2_ranking_client.result import SubscribeResult

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

result = client.subscribe_async(
    SubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')\
        .with_target_user_id('user-0002'),
    callback
)
import io.gs2.ranking.request.SubscribeRequest
import io.gs2.ranking.result.SubscribeResult

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

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

ユーザIDを購読

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
targetUserId string true 購読されるユーザID
パラメータ データ型 説明
item SubscribeUser 購読した購読対象

subscribeByUserId

同期処理

from gs2_ranking_client.request import SubscribeByUserIdRequest
from gs2_ranking_client.result import SubscribeByUserIdResult

result = client.subscribe_by_user_id(
    SubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0002')\
        .with_user_id('user-0001')\
        .with_target_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.SubscribeByUserIdRequest
import io.gs2.ranking.result.SubscribeByUserIdResult

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

非同期処理

from gs2_ranking_client.request import SubscribeByUserIdRequest
from gs2_ranking_client.result import SubscribeByUserIdResult

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

result = client.subscribe_by_user_id_async(
    SubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0002')\
        .with_user_id('user-0001')\
        .with_target_user_id('user-0001'),
    callback
)
import io.gs2.ranking.request.SubscribeByUserIdRequest
import io.gs2.ranking.result.SubscribeByUserIdResult

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

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

ユーザIDを指定してユーザIDを購読

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
userId string true 購読するユーザID
targetUserId string true 購読されるユーザID
パラメータ データ型 説明
item SubscribeUser 購読した購読対象

unsubscribe

同期処理

from gs2_ranking_client.request import UnsubscribeRequest
from gs2_ranking_client.result import UnsubscribeResult

result = client.unsubscribe(
    UnsubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')\
        .with_target_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.UnsubscribeRequest
import io.gs2.ranking.result.UnsubscribeResult

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

非同期処理

from gs2_ranking_client.request import UnsubscribeRequest
from gs2_ranking_client.result import UnsubscribeResult

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

result = client.unsubscribe_async(
    UnsubscribeRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')\
        .with_target_user_id('user-0002'),
    callback
)
import io.gs2.ranking.request.UnsubscribeRequest
import io.gs2.ranking.result.UnsubscribeResult

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

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

購読の購読を解除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
targetUserId string true 購読されるユーザID
パラメータ データ型 説明
item SubscribeUser 解除した購読対象

unsubscribeByUserId

同期処理

from gs2_ranking_client.request import UnsubscribeByUserIdRequest
from gs2_ranking_client.result import UnsubscribeByUserIdResult

result = client.unsubscribe_by_user_id(
    UnsubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0002')\
        .with_user_id('user-0001')\
        .with_target_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.UnsubscribeByUserIdRequest
import io.gs2.ranking.result.UnsubscribeByUserIdResult

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

非同期処理

from gs2_ranking_client.request import UnsubscribeByUserIdRequest
from gs2_ranking_client.result import UnsubscribeByUserIdResult

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

result = client.unsubscribe_by_user_id_async(
    UnsubscribeByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0002')\
        .with_user_id('user-0001')\
        .with_target_user_id('user-0001'),
    callback
)
import io.gs2.ranking.request.UnsubscribeByUserIdRequest
import io.gs2.ranking.result.UnsubscribeByUserIdResult

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

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

ユーザIDを指定して購読の購読を解除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリ名
userId string true 購読するユーザID
targetUserId string true 購読されるユーザID
パラメータ データ型 説明
item SubscribeUser 解除した購読対象

updateCategoryModelMaster

同期処理

from gs2_ranking_client.request import UpdateCategoryModelMasterRequest
from gs2_ranking_client.result import UpdateCategoryModelMasterResult

result = client.update_category_model_master(
    UpdateCategoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')\
        .with_description('description1')\
        .with_metadata('CATEGORY_0001')\
        .with_minimum_value(100)\
        .with_maximum_value(10000)\
        .with_order_direction('desc')\
        .with_scope('global')\
        .with_unique_by_user_id(True)\
        .with_calculate_interval_minutes(15)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.UpdateCategoryModelMasterRequest
import io.gs2.ranking.result.UpdateCategoryModelMasterResult

result = client.updateCategoryModelMaster(
    UpdateCategoryModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withCategoryName("category-0001")
        .withDescription("description1")
        .withMetadata("CATEGORY_0001")
        .withMinimumValue(100l)
        .withMaximumValue(10000l)
        .withOrderDirection("desc")
        .withScope("global")
        .withUniqueByUserId(true)
        .withCalculateIntervalMinutes(15)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_ranking_client.request import UpdateCategoryModelMasterRequest
from gs2_ranking_client.result import UpdateCategoryModelMasterResult

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

result = client.update_category_model_master_async(
    UpdateCategoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_category_name('category-0001')\
        .with_description('description1')\
        .with_metadata('CATEGORY_0001')\
        .with_minimum_value(100)\
        .with_maximum_value(10000)\
        .with_order_direction('desc')\
        .with_scope('global')\
        .with_unique_by_user_id(True)\
        .with_calculate_interval_minutes(15),
    callback
)
import io.gs2.ranking.request.UpdateCategoryModelMasterRequest
import io.gs2.ranking.result.UpdateCategoryModelMasterResult

result = client.updateCategoryModelMaster(
    UpdateCategoryModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withCategoryName("category-0001")
        .withDescription("description1")
        .withMetadata("CATEGORY_0001")
        .withMinimumValue(100l)
        .withMaximumValue(10000l)
        .withOrderDirection("desc")
        .withScope("global")
        .withUniqueByUserId(true)
        .withCalculateIntervalMinutes(15),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

カテゴリマスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
categoryName string true カテゴリモデル名
description string false カテゴリマスターの説明
metadata string false カテゴリマスターのメタデータ
minimumValue long false スコアの最小値
maximumValue long false スコアの最大値
orderDirection string true スコアのソート方向
scope string true ランキングの種類
uniqueByUserId boolean true ユーザID毎にスコアを1つしか登録されないようにする
calculateIntervalMinutes integer true スコアの集計間隔(分)
パラメータ データ型 説明
item CategoryModelMaster 更新したカテゴリマスター

updateCurrentRankingMaster

同期処理

from gs2_ranking_client.request import UpdateCurrentRankingMasterRequest
from gs2_ranking_client.result import UpdateCurrentRankingMasterResult

result = client.update_current_ranking_master(
    UpdateCurrentRankingMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-09-17",\n  "categories": [\n    {\n      "name": "category-0001",\n      "orderDirection": "asc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": true\n    },\n    {\n      "name": "category-0002",\n      "orderDirection": "desc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": false\n    },\n    {\n      "name": "category-0003",\n      "orderDirection": "asc",\n      "scope": "scoped",\n      "minimumValue": 100,\n      "maximumValue": 10000,\n      "uniqueByUserId": true\n    },\n    {\n      "name": "category-0004",\n      "orderDirection": "desc",\n      "scope": "scoped",\n      "minimumValue": 100,\n      "maximumValue": 10000,\n      "uniqueByUserId": false\n    },\n    {\n      "name": "category-0005",\n      "orderDirection": "asc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": true\n    }\n  ]\n}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.UpdateCurrentRankingMasterRequest
import io.gs2.ranking.result.UpdateCurrentRankingMasterResult

result = client.updateCurrentRankingMaster(
    UpdateCurrentRankingMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-09-17",\n  "categories": [\n    {\n      "name": "category-0001",\n      "orderDirection": "asc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": true\n    },\n    {\n      "name": "category-0002",\n      "orderDirection": "desc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": false\n    },\n    {\n      "name": "category-0003",\n      "orderDirection": "asc",\n      "scope": "scoped",\n      "minimumValue": 100,\n      "maximumValue": 10000,\n      "uniqueByUserId": true\n    },\n    {\n      "name": "category-0004",\n      "orderDirection": "desc",\n      "scope": "scoped",\n      "minimumValue": 100,\n      "maximumValue": 10000,\n      "uniqueByUserId": false\n    },\n    {\n      "name": "category-0005",\n      "orderDirection": "asc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": true\n    }\n  ]\n}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_ranking_client.request import UpdateCurrentRankingMasterRequest
from gs2_ranking_client.result import UpdateCurrentRankingMasterResult

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

result = client.update_current_ranking_master_async(
    UpdateCurrentRankingMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-09-17",\n  "categories": [\n    {\n      "name": "category-0001",\n      "orderDirection": "asc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": true\n    },\n    {\n      "name": "category-0002",\n      "orderDirection": "desc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": false\n    },\n    {\n      "name": "category-0003",\n      "orderDirection": "asc",\n      "scope": "scoped",\n      "minimumValue": 100,\n      "maximumValue": 10000,\n      "uniqueByUserId": true\n    },\n    {\n      "name": "category-0004",\n      "orderDirection": "desc",\n      "scope": "scoped",\n      "minimumValue": 100,\n      "maximumValue": 10000,\n      "uniqueByUserId": false\n    },\n    {\n      "name": "category-0005",\n      "orderDirection": "asc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": true\n    }\n  ]\n}'),
    callback
)
import io.gs2.ranking.request.UpdateCurrentRankingMasterRequest
import io.gs2.ranking.result.UpdateCurrentRankingMasterResult

result = client.updateCurrentRankingMaster(
    UpdateCurrentRankingMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-09-17",\n  "categories": [\n    {\n      "name": "category-0001",\n      "orderDirection": "asc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": true\n    },\n    {\n      "name": "category-0002",\n      "orderDirection": "desc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": false\n    },\n    {\n      "name": "category-0003",\n      "orderDirection": "asc",\n      "scope": "scoped",\n      "minimumValue": 100,\n      "maximumValue": 10000,\n      "uniqueByUserId": true\n    },\n    {\n      "name": "category-0004",\n      "orderDirection": "desc",\n      "scope": "scoped",\n      "minimumValue": 100,\n      "maximumValue": 10000,\n      "uniqueByUserId": false\n    },\n    {\n      "name": "category-0005",\n      "orderDirection": "asc",\n      "scope": "global",\n      "calculateIntervalMinutes": 15,\n      "uniqueByUserId": true\n    }\n  ]\n}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Ranking::CurrentRankingMaster
Properties:
  NamespaceName: String
  Settings: String

現在有効なランキング設定を更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
settings string true マスターデータ
パラメータ データ型 説明
item CurrentRankingMaster 更新した現在有効なランキング設定

updateCurrentRankingMasterFromGitHub

同期処理

from gs2_ranking_client.request import UpdateCurrentRankingMasterFromGitHubRequest
from gs2_ranking_client.result import UpdateCurrentRankingMasterFromGitHubResult

result = client.update_current_ranking_master_from_git_hub(
    UpdateCurrentRankingMasterFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.ranking.request.UpdateCurrentRankingMasterFromGitHubRequest
import io.gs2.ranking.result.UpdateCurrentRankingMasterFromGitHubResult

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

非同期処理

from gs2_ranking_client.request import UpdateCurrentRankingMasterFromGitHubRequest
from gs2_ranking_client.result import UpdateCurrentRankingMasterFromGitHubResult

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

result = client.update_current_ranking_master_from_git_hub_async(
    UpdateCurrentRankingMasterFromGitHubRequest()\
    callback
)
import io.gs2.ranking.request.UpdateCurrentRankingMasterFromGitHubRequest
import io.gs2.ranking.result.UpdateCurrentRankingMasterFromGitHubResult

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

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

現在有効なランキング設定を更新します

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

updateNamespace

同期処理

from gs2_ranking_client.request import UpdateNamespaceRequest
from gs2_ranking_client.result import UpdateNamespaceResult

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

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

非同期処理

from gs2_ranking_client.request import UpdateNamespaceRequest
from gs2_ranking_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('namespace-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.ranking.request.UpdateNamespaceRequest
import io.gs2.ranking.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-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-Ranking が提供するスクリプトトリガーはありません

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

CurrentRankingMaster

{
  "version": "2019-09-17"
  "categories": [
    {
      "name": "[string] カテゴリ名",
      "metadata": "[string] カテゴリのメタデータ",
      "minimumValue": "[long] スコアの最小値",
      "maximumValue": "[long] スコアの最大値",
      "orderDirection": "[string] スコアのソート方向",
      "scope": "[string] ランキングの種類",
      "uniqueByUserId": "[boolean] ユーザID毎にスコアを1つしか登録されないようにする",
      "calculateIntervalMinutes": "[integer] スコアの集計間隔(分)"
    }
  ]
}

現在有効なランキング設定

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

GS2-Ranking の制限・制約

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