> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Ranking SDK API リファレンス
各種プログラミング言語向け GS2-Ranking SDK の モデルの仕様 と API のリファレンス
## モデル
### Namespace
ネームスペース
ネームスペースは、一つのプロジェクト内で同じサービスを異なる用途で複数利用するためのエンティティです。
GS2 の各サービスはネームスペース単位で管理されます。ネームスペースが異なれば、同じサービスでも完全に独立したデータ空間として扱われます。
そのため、各サービスの利用を開始するにあたってネームスペースを作成する必要があります。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024文字 | ネームスペースGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | トランザクション設定
ランキング操作時のトランザクションの処理方法を制御する設定です。 |
| lastCalculatedAts | [List<CalculatedAt>](#calculatedat) | | | [] | 0 ~ 1000 items | 最終集計日時リスト
各カテゴリーのグローバルランキングが最後に集計された日時を記録するタイムスタンプのリスト。
カテゴリーごとに1エントリが維持され、再集計が完了すると対応するエントリが更新されます（新規カテゴリーの場合は新しいエントリが追加されます）。 |
| logSetting | [LogSetting](#logsetting) | | | | | ログ出力設定
ランキング関連の操作ログを GS2-Log に出力するための設定。
設定すると、スコア登録、ランキング取得、購読変更などのアクションが分析や監査のために記録されます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeNamespaces - ネームスペースの一覧を取得
createNamespace - ネームスペースを新規作成
getNamespace - ネームスペースを取得
updateNamespace - ネームスペースを更新
deleteNamespace - ネームスペースを削除
---
### TransactionSetting
トランザクション設定
トランザクション設定は、トランザクションの実行方法・整合性・非同期処理・競合回避の仕組みを制御する設定です。
自動実行（AutoRun）、アトミック実行（AtomicCommit）、GS2-Distributor を利用した非同期実行、スクリプト結果の一括適用、GS2-JobQueue による入手アクションの非同期化などを組み合わせ、ゲームロジックに応じた堅牢なトランザクション管理を可能にします。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| enableAutoRun | bool | | | false | | 発行したトランザクションをサーバーサイドで自動的に実行するか |
| enableAtomicCommit | bool | {enableAutoRun} == true | | false | | トランザクションの実行をアトミックにコミットするか
※ enableAutoRun が true であれば 有効 |
| transactionUseDistributor | bool | {enableAtomicCommit} == true | | false | | トランザクションを非同期処理で実行する
※ enableAtomicCommit が true であれば 有効 |
| commitScriptResultInUseDistributor | bool | {transactionUseDistributor} == true | | false | | スクリプトの結果コミット処理を非同期処理で実行するか
※ transactionUseDistributor が true であれば 有効 |
| acquireActionUseJobQueue | bool | {enableAtomicCommit} == true | | false | | 入手アクションを実行する際に GS2-JobQueue を使用するか
※ enableAtomicCommit が true であれば 有効 |
| distributorNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:distributor:default" | ~ 1024文字 | トランザクションの実行に使用する GS2-Distributor ネームスペースGRN |
| queueNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:queue:default" | ~ 1024文字 | トランザクションの実行に使用する GS2-JobQueue のネームスペースGRN |
**関連するメソッド:**
createNamespace - ネームスペースを新規作成
updateNamespace - ネームスペースを更新
**関連するモデル:**
Namespace - ネームスペース
---
### LogSetting
ログの出力設定
ログデータの出力設定を管理します。この型は、ログデータを書き出すために使用される GS2-Log ネームスペースの識別子（Namespace ID）を保持します。
ログネームスペースID(loggingNamespaceId)には、ログデータを収集し保存する GS2-Log のネームスペースを、GRNの形式で指定します。
この設定をすることで、設定されたネームスペース内で発生したAPIリクエスト・レスポンスのログデータが、対象の GS2-Log ネームスペース側へ出力されるようになります。
GS2-Log ではリアルタイムでログが提供され、システムの監視や分析、デバッグなどに利用できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| loggingNamespaceId | string | | ✓ | | ~ 1024文字 | ログを出力する GS2-Log のネームスペースGRN
「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。 |
**関連するメソッド:**
createNamespace - ネームスペースを新規作成
updateNamespace - ネームスペースを更新
**関連するモデル:**
Namespace - ネームスペース
---
### GitHubCheckoutSetting
GitHubからマスターデータをチェックアウトする設定
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| apiKeyId | string | | ✓ | | ~ 1024文字 | GitHub APIキーのGRN |
| repositoryName | string | | ✓ | | ~ 1024文字 | リポジトリ名 |
| sourcePath | string | | ✓ | | ~ 1024文字 | マスターデータ（JSON）ファイルのパス |
| referenceType | 文字列列挙型
enum {
"commit_hash",
"branch",
"tag"
}
| | ✓ | | | コードの取得元"commit_hash": コミットハッシュ / "branch": ブランチ / "tag": タグ / |
| commitHash | string | {referenceType} == "commit_hash" | ✓※ | | ~ 1024文字 | コミットハッシュ
※ referenceType が "commit_hash" であれば 必須 |
| branchName | string | {referenceType} == "branch" | ✓※ | | ~ 1024文字 | ブランチ名
※ referenceType が "branch" であれば 必須 |
| tagName | string | {referenceType} == "tag" | ✓※ | | ~ 1024文字 | タグ名
※ referenceType が "tag" であれば 必須 |
**関連するメソッド:**
updateCurrentRankingMasterFromGitHub - 現在アクティブなランキングモデルのマスターデータをGitHubから更新
---
### Subscribe
購読
スコープランキングの購読状態を保持し、プレイヤーがどのユーザーのスコアをフォローしているかを追跡します。
スコープランキングモードでは、各プレイヤーは購読したユーザーに基づくパーソナライズされたリーダーボードを参照します。
targetUserIds はプレイヤーが追跡したいユーザーのリストで、subscribedUserIds は確認済み（相互または承認済み）の購読を表します。
ユーザーごと・カテゴリーごとに最大10,000件の購読が可能です。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| subscribeId | string | | ※ | | ~ 1024文字 | 購読GRN
※ サーバーが自動で設定 |
| categoryName | string | | ✓ | | ~ 128文字 | カテゴリー名 |
| userId | string | | ✓ | | ~ 128文字 | ユーザーID |
| targetUserIds | List<string> | | | [] | 0 ~ 10000 items | 購読対象ユーザーIDリスト
スコープランキングでプレイヤーが追跡したいユーザーIDのリスト。
このリストにユーザーIDを追加すると、そのユーザーのスコアがプレイヤーのパーソナライズされたリーダーボードに含まれます。最大10,000件。 |
| subscribedUserIds | List<string> | | | [] | 0 ~ 10000 items | 被購読ユーザーIDリスト
このプレイヤーのスコアを購読している（フォローしている）ユーザーIDのリスト。
購読関係の逆方向を表し、これらのユーザーのスコープランキングにこのプレイヤーのスコアが表示されます。最大10,000件。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
---
### Score
スコア
ゲームプレイヤーごと・カテゴリーごとに登録されたスコアを保持するエンティティです。
各スコアエントリはユニークIDで識別され、カテゴリーとスコア登録ユーザーに関連付けられます。
合算モードでは、新しいスコアは個別のエントリを作成するのではなく、AddScore 操作で既存の合計に加算されます。
カテゴリーの最小値・最大値の範囲外のスコアは登録時に拒否されます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| scoreId | string | | ※ | | ~ 1024文字 | スコアGRN
※ サーバーが自動で設定 |
| categoryName | string | | ✓ | | ~ 128文字 | カテゴリー名 |
| userId | string | | ✓ | | ~ 128文字 | ユーザーID |
| uniqueId | string | | ✓ | UUID | ~ 36文字 | ユニークID
このスコアエントリを一意に識別する UUID。
作成時に自動生成されます。uniqueByUserId が無効の場合、同一ユーザーの同一カテゴリー内の複数スコアエントリを区別するために使用されます。 |
| scorerUserId | string | | ✓ | | ~ 128文字 | ユーザーID |
| score | long | | ✓ | | 0 ~ 9223372036854775805 | スコア
プレイヤーが登録したスコア値。
カテゴリーに設定された最小値・最大値の範囲内である必要があります。合算モードでは、AddScore 操作でこの値をインクリメントできます。 |
| metadata | string | | | | ~ 512文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeScores - スコアの一覧を取得
describeScoresByUserId - ユーザーIDを指定してスコアの一覧を取得
getScore - スコアを取得
getScoreByUserId - ユーザーIDを指定してスコアを取得
putScore - スコアを登録
putScoreByUserId - ユーザーIDを指定してスコアを登録
---
### Ranking
ランキング
ランキングリーダーボードの1エントリを表し、ユーザーの順位、スコア、および関連メタデータを含みます。
グローバルランキング（全プレイヤーが共有ボードでバッチ集計により競争）とスコープランキング（購読したプレイヤーに基づくユーザーごとのボードでリアルタイム反映）の2種類があります。
ランキングはカテゴリーに設定されたソート方向で並び替えられ、同スコアのエントリは同順位を共有しつつ異なるインデックスを保持します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| rank | long | | ✓ | | 1 ~ 9223372036854775805 | 順位
このエントリのランキング順位（1始まり）。
同スコアのエントリは同じ順位を共有します。例えば、2ユーザーが1位タイの場合、両方とも順位1となり次のエントリは順位3になります。 |
| index | long | | ✓ | | 0 ~ 9223372036854775805 | インデックス
ランキングリスト内のゼロベースの連番インデックス。
rank と異なり、複数のエントリが同スコアを共有していてもインデックスは常にユニークで連続します。ページネーションや範囲ベースのクエリに使用されます。 |
| categoryName | string | | ✓ | | ~ 128文字 | カテゴリーモデル名 |
| userId | string | | ✓ | | ~ 128文字 | ユーザーID |
| score | long | | ✓ | | 0 ~ 9223372036854775805 | スコア
このランキングエントリのスコア値。
合算モードの場合、登録された全スコアの累積合計です。ランキングのソート順に使用される値はカテゴリーの orderDirection 設定に依存します。 |
| metadata | string | | | | ~ 512文字 | メタデータ
このランキングエントリに関連付けられた任意のメタデータ。
スコア登録時に設定され、ランキング結果と共に返されます。最大512文字。 |
| createdAt | long | | ✓ | | | 作成日時
UNIX 時間・ミリ秒
※ サーバー側で自動的に設定 |
**関連するメソッド:**
describeRankings - ランキングを取得
describeRankingssByUserId - ユーザーIDを指定してランキングを取得
describeNearRankings - 指定したスコア付近のランキングを取得
getRanking - ランキングを取得
getRankingByUserId - ユーザーIDを指定してランキングを取得
---
### SubscribeUser
購読ユーザー
スコープランキングカテゴリー内の個別の購読関係を表します。
各エントリは、親ユーザーが指定カテゴリーでターゲットユーザーのスコアを購読（フォロー）していることを示します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| subscribeUserId | string | | ※ | | ~ 1024文字 | 購読対象GRN
※ サーバーが自動で設定 |
| categoryName | string | | ✓ | | ~ 128文字 | カテゴリーモデル名 |
| userId | string | | ✓ | | ~ 128文字 | ユーザーID |
| targetUserId | string | | ✓ | | ~ 128文字 | 購読対象ユーザーID
購読先のプレイヤーのユーザーID。
このユーザーのスコアが、購読元ユーザーの指定カテゴリーにおけるスコープランキングに表示されます。 |
**関連するメソッド:**
subscribe - 対象ユーザーを購読
subscribeByUserId - ユーザーIDを指定して対象のユーザーを購読
getSubscribe - 購読対象ユーザー情報を取得
getSubscribeByUserId - ユーザーIDを指定して購読を取得
unsubscribe - 対象ユーザーの購読を解除
unsubscribeByUserId - ユーザーIDを指定して対象ユーザーの購読を解除
describeSubscribesByCategoryName - 購読しているユーザーのユーザーIDの一覧取得
describeSubscribesByCategoryNameAndUserId - ユーザーIDを指定してそのユーザーが購読しているユーザーの一覧取得
---
### CategoryModel
カテゴリーモデル
カテゴリー毎に異なるランキングを作成できます。
カテゴリーには登録できるスコアの最小値・最大値を設定でき、その範囲外のスコアは破棄されます。
ランキングを集計する際にスコアを小さいものを上位（昇順）にするか、大きいものを上位（降順）にするかを設定できます。
ランキングの種類として `グローバル` と `スコープ` を選択できます。
グローバルは全プレイヤーが同じ結果を参照するもので、スコープはフレンド内ランキングや、ギルド内ランキングのようなゲームプレイヤー毎に結果の異なるランキングです。
グローバルランキングはカテゴリーごとにランキングの集計間隔を15分～24時間で設定できます。
スコープランキングはリアルタイムで集計結果が反映されます。
ランキングデータには世代という設定があり、世代を変更することで登録されたスコアをリセットすることができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| categoryModelId | string | | ※ | | ~ 1024文字 | カテゴリーモデルGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 1024文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | スコアの最小値
このカテゴリーに登録できるスコアの最小値。
この閾値を下回るスコアは登録時に拒否されます。未設定の場合、下限はありません。 |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | スコアの最大値
このカテゴリーに登録できるスコアの最大値。
この閾値を上回るスコアは登録時に拒否されます。未設定の場合、上限はありません。 |
| sum | bool | | | false | | 合算モード
有効にすると、新しく登録されたスコアは既存のスコアを置き換えるのではなく、合計に加算されます。
ランキングは蓄積された合計値に基づいて計算されます。無効の場合、各スコア登録は独立したエントリとして扱われます。 |
| orderDirection | 文字列列挙型
enum {
"asc",
"desc"
}
| | ✓ | | | ソート方向
ランキング集計のソート順を決定します。
"asc"（昇順）は低いスコアを上位とし、タイムベースやゴルフ式のランキングに適しています。
"desc"（降順）は高いスコアを上位とし、ポイントベースやハイスコアランキングに適しています。"asc": 昇順 / "desc": 降順 / |
| scope | 文字列列挙型
enum {
"global",
"scoped"
}
| | ✓ | | | ランキングの種類
このカテゴリーのランキングタイプ。
"global" は全プレイヤーが共有する単一のリーダーボードを作成し、設定された間隔でバッチ集計されます。
"scoped" は購読したプレイヤー（フレンドやギルドメンバー等）に基づくユーザーごとのリーダーボードを作成し、スコアがリアルタイムで反映されます。"global": グローバル / "scoped": スコープ / |
| globalRankingSetting | [GlobalRankingSetting](#globalrankingsetting) | {scope} == "global" | ✓※ | | | グローバルランキング設定
グローバルランキングモード固有の設定。集計間隔、固定時刻、スコアのユニーク性、世代管理、および追加の期間限定スコープを含みます。
scope が "global" に設定されている場合のみ適用されます。
※ scope が "global" であれば 必須 |
| entryPeriodEventId | string | | | | ~ 1024文字 | スコア登録期間イベントID
スコア登録を受け付ける期間を定義する GS2-Schedule イベントの GRN。
この期間外のスコア登録リクエストは拒否されます。未設定の場合、スコアはいつでも登録できます。 |
| accessPeriodEventId | string | | | | ~ 1024文字 | アクセス期間イベントID
ランキングデータを閲覧できる期間を定義する GS2-Schedule イベントの GRN。
この期間外のランキング取得リクエストは拒否されます。未設定の場合、ランキングはいつでもアクセスできます。 |
**関連するメソッド:**
describeCategoryModels - カテゴリモデルの一覧を取得
getCategoryModel - カテゴリモデルを取得
---
### Scope
集計スコープ
グローバルランキングモードにおける追加の期間限定集計スコープを定義します。
通常、グローバルランキングは登録されたスコア全てを対象に集計が行われます。
スコープを追加することで、指定した日数以内に登録されたスコアのみを対象とする別ランキングを作成でき、全期間ランキングと併せてデイリー・ウィークリー・マンスリーなどのリーダーボードを実現できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | スコープ名
カテゴリー内でこの集計スコープを一意に識別する名前。
複数の期間限定ランキングボードを区別するために使用されます（例: "daily", "weekly"）。最大128文字。 |
| targetDays | long | | ✓ | | 1 ~ 365 | 集計対象日数
集計ウィンドウに含める日数。
現在時刻からこの日数以内に登録されたスコアのみがスコープランキングの対象となります。範囲: 1～365日。 |
**関連するモデル:**
CategoryModel - カテゴリーモデル
GlobalRankingSetting - グローバルランキング設定
CategoryModelMaster - カテゴリーモデルマスター
---
### GlobalRankingSetting
グローバルランキング設定
グローバルは全プレイヤーが同じ結果を参照するものです。
ランキングの集計間隔を15分～24時間で設定できます。
ランキングデータには世代という設定があり、世代を変更することで登録されたスコアをリセットすることができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| uniqueByUserId | bool | | | true | | ユーザーID毎にユニーク
有効にすると、ランキング内でユーザーIDごとに1つのスコアのみ保持されます。
ユーザーが新しいスコアを登録すると、ソート方向に基づいてより良いスコアに置き換えられます。
無効にすると、同一ユーザーから複数のスコアエントリが許可され、合算モードや複数エントリによる競争が可能になります。 |
| calculateIntervalMinutes | int | | ✓ | | 15 ~ 1440 | 集計間隔（分）
連続するランキング再集計の間隔（分）。
システムはこの間隔で、登録された全スコアに基づいてグローバルランキングを定期的に再集計します。
範囲: 15～1440分（15分～24時間）。 |
| calculateFixedTiming | [FixedTiming](#fixedtiming) | | | | | 集計時刻固定設定
ランキング再集計が開始される1日の固定時刻（UTC）を指定します。
未設定の場合、再集計は不定の基準時刻から定期間隔で実行されます。
これを設定することで、毎日予測可能で一貫した時刻に再集計が行われるようになります。 |
| additionalScopes | [List<Scope>](#scope) | | | | 0 ~ 10 items | 追加スコープリスト
追加の期間限定集計スコープのリスト。
各スコープは指定した日数以内に登録されたスコアのみを対象とする別ランキングを定義します。
全期間のグローバルランキングと併せて、デイリー・ウィークリー・マンスリーなどのリーダーボードを作成できます。最大10件。 |
| ignoreUserIds | List<string> | | | | 0 ~ 10000 items | 除外ユーザーIDリスト
ランキング集計からスコアを除外するユーザーIDのリスト。
テストアカウント、管理者アカウント、または既知の不正ユーザーをリーダーボードから除外するのに使用します。最大10,000件。 |
| generation | string | | | | ~ 256文字 | 世代
現在のランキング世代を表す任意の文字列。
この値を変更すると、前の世代のスコアはランキング集計に含まれなくなるため、実質的にスコアがリセットされます。
シーズン制リセットや定期的なランキングリセットの実装に使用します。最大256文字。 |
**関連するメソッド:**
createCategoryModelMaster - カテゴリモデルマスターを新規作成
updateCategoryModelMaster - カテゴリモデルマスターを更新
**関連するモデル:**
CategoryModel - カテゴリーモデル
CategoryModelMaster - カテゴリーモデルマスター
---
### FixedTiming
集計時刻固定設定
グローバルランキングの集計が開始される固定時刻を指定します。
この設定がない場合、ランキング集計は不定の基準時刻から定期間隔で実行されます。
固定の時・分を指定することで、毎日の集計開始時刻（UTC）を予測可能にでき、深夜0時や特定の時刻に集計を開始するよう制御できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| hour | int | | | | 0 ~ 23 | 時
ランキング集計が開始される時刻の時（UTC）。
0～23 の整数で指定します。 |
| minute | int | | | | 0 ~ 59 | 分
指定した時刻の分。
0～59 の整数で指定します。 |
**関連するモデル:**
GlobalRankingSetting - グローバルランキング設定
---
### CalculatedAt
最終集計日時
特定のカテゴリーに対する最後のランキング集計のタイムスタンプを記録します。
ネームスペースはカテゴリーごとに1つずつこのエントリのリストを保持し、グローバルランキングの再集計が完了するたびに更新されます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| categoryName | string | | ✓ | | ~ 128文字 | カテゴリー名
最終集計時刻が追跡されるカテゴリーモデルの名前。
同じネームスペース内で定義された CategoryModel の name フィールドと一致します。 |
| calculatedAt | long | | ✓ | | | 集計日時
このカテゴリーのランキング集計が最後に完了したタイムスタンプ。
UNIX 時間（ミリ秒）で表現されます。ランキング再集計が完了した際にサーバーが自動的に設定します。 |
**関連するモデル:**
Namespace - ネームスペース
---
### CurrentRankingMaster
現在アクティブなランキングモデルのマスターデータ
現在ネームスペース内で有効な、ランキングのモデルの定義を記述したマスターデータです。
GS2ではマスターデータの管理にJSON形式のファイルを使用します。
ファイルをアップロードすることで、実際にサーバーに設定を反映することができます。
JSONファイルを作成する方法として、マネージメントコンソール内にマスターデータエディタを提供しています。
また、よりゲームの運営に相応しいツールを作成し、適切なフォーマットのJSONファイルを書き出すことでもサービスを利用可能です。
**ℹ️ Note**
JSONファイルの形式については [GS2-Ranking マスターデータリファレンス](api_reference/ranking/master_data/) をご参照ください。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024文字 | ネームスペースGRN
※ サーバーが自動で設定 |
| settings | string | | ✓ | | ~ 5242880 バイト (5MB) | マスターデータ |
**関連するメソッド:**
exportMaster - モデルマスターを有効化可能なマスターデータ形式でエクスポート
getCurrentRankingMaster - 現在アクティブなランキングモデルのマスターデータを取得
updateCurrentRankingMaster - 現在アクティブなランキングモデルのマスターデータを更新
updateCurrentRankingMasterFromGitHub - 現在アクティブなランキングモデルのマスターデータをGitHubから更新
---
### CategoryModelMaster
カテゴリーモデルマスター
カテゴリーモデルマスターは、ゲーム内で使用されるカテゴリーモデルの編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。
インポート・更新処理を行うことで、実際にゲームから参照されるカテゴリーモデルとして反映されます。
カテゴリー毎に異なるランキングを作成できます。
カテゴリーには登録できるスコアの最小値・最大値を設定でき、その範囲外のスコアは破棄されます。
ランキングを集計する際にスコアを小さいものを上位（昇順）にするか、大きいものを上位（降順）にするかを設定できます。
ランキングの種類として `グローバル` と `スコープ` を選択できます。
グローバルは全プレイヤーが同じ結果を参照するもので、スコープはフレンド内ランキングや、ギルド内ランキングのようなゲームプレイヤー毎に結果の異なるランキングです。
グローバルランキングはカテゴリーごとにランキングの集計間隔を15分～24時間で設定できます。
スコープランキングはリアルタイムで集計結果が反映されます。
ランキングデータには世代という設定があり、世代を変更することで登録されたスコアをリセットすることができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| categoryModelId | string | | ※ | | ~ 1024文字 | カテゴリマスターGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 1024文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | スコアの最小値
このカテゴリーに登録できるスコアの最小値。
この閾値を下回るスコアは登録時に拒否されます。未設定の場合、下限はありません。 |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | スコアの最大値
このカテゴリーに登録できるスコアの最大値。
この閾値を上回るスコアは登録時に拒否されます。未設定の場合、上限はありません。 |
| sum | bool | | | false | | 合算モード
有効にすると、新しく登録されたスコアは既存のスコアを置き換えるのではなく、合計に加算されます。
ランキングは蓄積された合計値に基づいて計算されます。無効の場合、各スコア登録は独立したエントリとして扱われます。 |
| orderDirection | 文字列列挙型
enum {
"asc",
"desc"
}
| | ✓ | | | ソート方向
ランキング集計のソート順を決定します。
"asc"（昇順）は低いスコアを上位とし、タイムベースやゴルフ式のランキングに適しています。
"desc"（降順）は高いスコアを上位とし、ポイントベースやハイスコアランキングに適しています。"asc": 昇順 / "desc": 降順 / |
| scope | 文字列列挙型
enum {
"global",
"scoped"
}
| | ✓ | | | ランキングの種類
このカテゴリーのランキングタイプ。
"global" は全プレイヤーが共有する単一のリーダーボードを作成し、設定された間隔でバッチ集計されます。
"scoped" は購読したプレイヤー（フレンドやギルドメンバー等）に基づくユーザーごとのリーダーボードを作成し、スコアがリアルタイムで反映されます。"global": グローバル / "scoped": スコープ / |
| globalRankingSetting | [GlobalRankingSetting](#globalrankingsetting) | {scope} == "global" | ✓※ | | | グローバルランキング設定
グローバルランキングモード固有の設定。集計間隔、固定時刻、スコアのユニーク性、世代管理、および追加の期間限定スコープを含みます。
scope が "global" に設定されている場合のみ適用されます。
※ scope が "global" であれば 必須 |
| entryPeriodEventId | string | | | | ~ 1024文字 | スコア登録期間イベントID
スコア登録を受け付ける期間を定義する GS2-Schedule イベントの GRN。
この期間外のスコア登録リクエストは拒否されます。未設定の場合、スコアはいつでも登録できます。 |
| accessPeriodEventId | string | | | | ~ 1024文字 | アクセス期間イベントID
ランキングデータを閲覧できる期間を定義する GS2-Schedule イベントの GRN。
この期間外のランキング取得リクエストは拒否されます。未設定の場合、ランキングはいつでもアクセスできます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeCategoryModelMasters - カテゴリモデルマスターの一覧を取得
createCategoryModelMaster - カテゴリモデルマスターを新規作成
getCategoryModelMaster - カテゴリモデルマスターを取得
updateCategoryModelMaster - カテゴリモデルマスターを更新
deleteCategoryModelMaster - カテゴリモデルマスターを削除
---
## メソッド
### describeNamespaces
ネームスペースの一覧を取得
プロジェクト内において、サービス単位で作成されたネームスペースの一覧を取得します。
オプションのページトークンを使用して、リストの特定の位置からデータの取得を開始できます。
また、取得するネームスペースの数を制限することも可能です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namePrefix | string | | | | ~ 64文字 | ネームスペース名のフィルター接頭辞 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Namespace>](#namespace) | ネームスペースのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&ranking.DescribeNamespacesRequest {
NamePrefix: nil,
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeNamespaces(
(new DescribeNamespacesRequest())
->withNamePrefix(null)
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeNamespacesRequest;
import io.gs2.ranking.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeNamespacesResult result = client.describeNamespaces(
new DescribeNamespacesRequest()
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2Ranking.Request.DescribeNamespacesRequest()
.WithNamePrefix(null)
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2Ranking.DescribeNamespacesRequest()
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_namespaces(
ranking.DescribeNamespacesRequest()
.with_name_prefix(None)
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_namespaces({
namePrefix=nil,
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_namespaces_async({
namePrefix=nil,
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createNamespace
ネームスペースを新規作成
ネームスペースの名前、説明、および各種設定を含む詳細情報を指定する必要があります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | トランザクション設定
ランキング操作時のトランザクションの処理方法を制御する設定です。 |
| logSetting | [LogSetting](#logsetting) | | | | | ログ出力設定
ランキング関連の操作ログを GS2-Log に出力するための設定。
設定すると、スコア登録、ランキング取得、購読変更などのアクションが分析や監査のために記録されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 作成したネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&ranking.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
TransactionSetting: nil,
LogSetting: &ranking.LogSetting{
LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting(null)
->withLogSetting((new \Gs2\Ranking\Model\LogSetting())
->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CreateNamespaceRequest;
import io.gs2.ranking.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(null)
.withLogSetting(new io.gs2.ranking.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2Ranking.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(null)
.WithLogSetting(new Gs2.Gs2Ranking.Model.LogSetting()
.WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.createNamespace(
new Gs2Ranking.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(null)
.withLogSetting(new Gs2Ranking.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.create_namespace(
ranking.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_transaction_setting(None)
.with_log_setting(
ranking.LogSetting()
.with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
transactionSetting=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
transactionSetting=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getNamespaceStatus
ネームスペースの状態を取得
指定されたネームスペースの現在の状態を取得します。
状態には、ネームスペースがアクティブか、削除済みかが含まれます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| status | string | ネームスペースの状態
"ACTIVE": 有効 / "DELETED": 削除済み / |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&ranking.GetNamespaceStatusRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
status := result.Status
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getNamespaceStatus(
(new GetNamespaceStatusRequest())
->withNamespaceName("namespace-0001")
);
$status = $result->getStatus();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetNamespaceStatusRequest;
import io.gs2.ranking.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetNamespaceStatusResult result = client.getNamespaceStatus(
new GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
String status = result.getStatus();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2Ranking.Request.GetNamespaceStatusRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var status = result.Status;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2Ranking.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_namespace_status(
ranking.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_namespace_status({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
status = result.status;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_namespace_status_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
status = result.status;
```
---
### getNamespace
ネームスペースを取得
指定されたネームスペースの詳細情報を取得します。
これには、ネームスペースの名前、説明、およびその他の設定情報が含まれます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | ネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&ranking.GetNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getNamespace(
(new GetNamespaceRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetNamespaceRequest;
import io.gs2.ranking.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetNamespaceResult result = client.getNamespace(
new GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2Ranking.Request.GetNamespaceRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getNamespace(
new Gs2Ranking.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_namespace(
ranking.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_namespace({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_namespace_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateNamespace
ネームスペースを更新
指定されたネームスペースの設定を更新します。
ネームスペースの説明や、特定の設定を変更することができます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | トランザクション設定
ランキング操作時のトランザクションの処理方法を制御する設定です。 |
| logSetting | [LogSetting](#logsetting) | | | | | ログ出力設定
ランキング関連の操作ログを GS2-Log に出力するための設定。
設定すると、スコア登録、ランキング取得、購読変更などのアクションが分析や監査のために記録されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 更新したネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&ranking.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
TransactionSetting: nil,
LogSetting: &ranking.LogSetting{
LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting(null)
->withLogSetting((new \Gs2\Ranking\Model\LogSetting())
->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UpdateNamespaceRequest;
import io.gs2.ranking.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(null)
.withLogSetting(new io.gs2.ranking.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2Ranking.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(null)
.WithLogSetting(new Gs2.Gs2Ranking.Model.LogSetting()
.WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2Ranking.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(null)
.withLogSetting(new Gs2Ranking.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.update_namespace(
ranking.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_transaction_setting(None)
.with_log_setting(
ranking.LogSetting()
.with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
transactionSetting=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
transactionSetting=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteNamespace
ネームスペースを削除
指定されたネームスペースを削除します。
この操作は不可逆であり、削除されたネームスペースに関連するすべてのデータは回復不能になります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 削除したネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&ranking.DeleteNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->deleteNamespace(
(new DeleteNamespaceRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DeleteNamespaceRequest;
import io.gs2.ranking.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DeleteNamespaceResult result = client.deleteNamespace(
new DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2Ranking.Request.DeleteNamespaceRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2Ranking.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.delete_namespace(
ranking.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.delete_namespace({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.delete_namespace_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getServiceVersion
マイクロサービスのバージョンを取得
#### Request
リクエストパラメータ: なし
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | string | バージョン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&ranking.GetServiceVersionRequest {
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getServiceVersion(
(new GetServiceVersionRequest())
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetServiceVersionRequest;
import io.gs2.ranking.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetServiceVersionResult result = client.getServiceVersion(
new GetServiceVersionRequest()
);
String item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2Ranking.Request.GetServiceVersionRequest(),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2Ranking.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_service_version(
ranking.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_service_version({
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_service_version_async({
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### dumpUserDataByUserId
指定したユーザーIDに紐づくデータのダンプを取得
個人情報保護の法的要件を満たすために使用したり、データのバックアップや移行に使用できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
返り値: なし
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&ranking.DumpUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->dumpUserDataByUserId(
(new DumpUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DumpUserDataByUserIdRequest;
import io.gs2.ranking.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DumpUserDataByUserIdResult result = client.dumpUserDataByUserId(
new DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2Ranking.Request.DumpUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2Ranking.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.dump_user_data_by_user_id(
ranking.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.dump_user_data_by_user_id({
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.dump_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### checkDumpUserDataByUserId
指定したユーザーIDに紐づくデータのダンプが完了しているか確認
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| url | string | 出力データのURL |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&ranking.CheckDumpUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
url := result.Url
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->checkDumpUserDataByUserId(
(new CheckDumpUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$url = $result->getUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.ranking.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
CheckDumpUserDataByUserIdResult result = client.checkDumpUserDataByUserId(
new CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
String url = result.getUrl();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2Ranking.Request.CheckDumpUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var url = result.Url;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2Ranking.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
ranking.CheckDumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
url = result.url
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.check_dump_user_data_by_user_id({
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
url = result.url;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.check_dump_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
url = result.url;
```
---
### cleanUserDataByUserId
ユーザーデータの完全削除
指定されたユーザーIDに紐づくデータのクリーニングを実行します。
これにより、特定のユーザーデータをプロジェクトから安全に削除できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
返り値: なし
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&ranking.CleanUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->cleanUserDataByUserId(
(new CleanUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CleanUserDataByUserIdRequest;
import io.gs2.ranking.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
CleanUserDataByUserIdResult result = client.cleanUserDataByUserId(
new CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2Ranking.Request.CleanUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2Ranking.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.clean_user_data_by_user_id(
ranking.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.clean_user_data_by_user_id({
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.clean_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### checkCleanUserDataByUserId
指定したユーザーIDに紐づくデータの削除が完了しているか確認
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
返り値: なし
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&ranking.CheckCleanUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->checkCleanUserDataByUserId(
(new CheckCleanUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.ranking.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
CheckCleanUserDataByUserIdResult result = client.checkCleanUserDataByUserId(
new CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2Ranking.Request.CheckCleanUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2Ranking.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
ranking.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.check_clean_user_data_by_user_id({
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.check_clean_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### prepareImportUserDataByUserId
指定したユーザーIDに紐づくデータのインポートを準備
インポートに使用できるデータは GS2 によってエクスポートして取得したデータに限定され、古いデータはインポートに失敗する可能性があります。
エクスポートしたユーザーIDと異なるユーザーIDでインポートすることができますが、ユーザーデータのペイロード内にユーザーIDが含まれる場合はその限りではありません。
このAPIの戻り値で応答されたURLにエクスポートした zip ファイルをアップロードし、importUserDataByUserId を呼び出すことで実際のインポート処理を開始できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| uploadToken | string | アップロード後に結果を反映する際に使用するトークン |
| uploadUrl | string | ユーザーデータアップロード処理の実行に使用するURL |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&ranking.PrepareImportUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->prepareImportUserDataByUserId(
(new PrepareImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$uploadToken = $result->getUploadToken();
$uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.ranking.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
PrepareImportUserDataByUserIdResult result = client.prepareImportUserDataByUserId(
new PrepareImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
String uploadToken = result.getUploadToken();
String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2Ranking.Request.PrepareImportUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var uploadUrl = result.UploadUrl;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2Ranking.PrepareImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const uploadToken = result.getUploadToken();
const uploadUrl = result.getUploadUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
ranking.PrepareImportUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
upload_token = result.upload_token
upload_url = result.upload_url
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.prepare_import_user_data_by_user_id({
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.prepare_import_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
---
### importUserDataByUserId
指定したユーザーIDに紐づくデータのインポートを実行
インポートに使用できるデータは GS2 によってエクスポートして取得したデータに限定され、古いデータはインポートに失敗する可能性があります。
エクスポートしたユーザーIDと異なるユーザーIDでインポートすることができますが、ユーザーデータのペイロード内にユーザーIDが含まれる場合はその限りではありません。
このAPIを呼び出す前に prepareImportUserDataByUserId を呼び出して、アップロード準備を完了させる必要があります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| uploadToken | string | | ✓| | ~ 1024文字 | アップロード準備で受け取ったトークン |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
返り値: なし
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&ranking.ImportUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
UploadToken: pointy.String("upload-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->importUserDataByUserId(
(new ImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withUploadToken("upload-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.ImportUserDataByUserIdRequest;
import io.gs2.ranking.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
ImportUserDataByUserIdResult result = client.importUserDataByUserId(
new ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2Ranking.Request.ImportUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithUploadToken("upload-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2Ranking.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.import_user_data_by_user_id(
ranking.ImportUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_upload_token('upload-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.import_user_data_by_user_id({
userId="user-0001",
uploadToken="upload-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.import_user_data_by_user_id_async({
userId="user-0001",
uploadToken="upload-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### checkImportUserDataByUserId
指定したユーザーIDに紐づくデータのインポートが完了しているか確認
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| uploadToken | string | | ✓| | ~ 1024文字 | アップロード準備で受け取ったトークン |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| url | string | 出力ログのURL |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&ranking.CheckImportUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
UploadToken: pointy.String("upload-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
url := result.Url
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->checkImportUserDataByUserId(
(new CheckImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withUploadToken("upload-0001")
->withTimeOffsetToken(null)
);
$url = $result->getUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CheckImportUserDataByUserIdRequest;
import io.gs2.ranking.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
CheckImportUserDataByUserIdResult result = client.checkImportUserDataByUserId(
new CheckImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
String url = result.getUrl();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2Ranking.Request.CheckImportUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithUploadToken("upload-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var url = result.Url;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2Ranking.CheckImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.check_import_user_data_by_user_id(
ranking.CheckImportUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_upload_token('upload-0001')
.with_time_offset_token(None)
)
url = result.url
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.check_import_user_data_by_user_id({
userId="user-0001",
uploadToken="upload-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
url = result.url;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.check_import_user_data_by_user_id_async({
userId="user-0001",
uploadToken="upload-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
url = result.url;
```
---
### subscribe
対象ユーザーを購読
指定したカテゴリにおいて、指定した対象ユーザーのランキングを購読します。対象ユーザーのスコアがリクエストしたユーザーのスコープ付きランキングに含まれるようになります。自分自身を購読することはできません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリー名 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| targetUserId | string | | ✓| | ~ 128文字 | 購読するユーザーID |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 購読対象ユーザー情報 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.Subscribe(
&ranking.SubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
TargetUserId: pointy.String("user-0002"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\SubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->subscribe(
(new SubscribeRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withTargetUserId("user-0002")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.SubscribeRequest;
import io.gs2.ranking.result.SubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
SubscribeResult result = client.subscribe(
new SubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
SubscribeUser item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.Subscribe(
new Gs2.Gs2Ranking.Request.SubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithTargetUserId("user-0002"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.subscribe(
new Gs2Ranking.SubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.subscribe(
ranking.SubscribeRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_target_user_id('user-0002')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.subscribe({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.subscribe_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### subscribeByUserId
ユーザーIDを指定して対象のユーザーを購読
指定したユーザーに代わって、指定したカテゴリにおいて指定した対象ユーザーのランキングを購読します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリー名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| targetUserId | string | | ✓| | ~ 128文字 | 購読するユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 購読対象ユーザー情報 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.SubscribeByUserId(
&ranking.SubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
TargetUserId: pointy.String("user-0002"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\SubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->subscribeByUserId(
(new SubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withTargetUserId("user-0002")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.SubscribeByUserIdRequest;
import io.gs2.ranking.result.SubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
SubscribeByUserIdResult result = client.subscribeByUserId(
new SubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
SubscribeUser item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.SubscribeByUserId(
new Gs2.Gs2Ranking.Request.SubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithTargetUserId("user-0002")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.subscribeByUserId(
new Gs2Ranking.SubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.subscribe_by_user_id(
ranking.SubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_target_user_id('user-0002')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.subscribe_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
targetUserId="user-0002",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.subscribe_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
targetUserId="user-0002",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeScores
スコアの一覧を取得
指定したカテゴリにおいて、指定したスコア投稿者が登録したスコアのリストをページネーション付きで取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| scorerUserId | string | | ✓| | ~ 128文字 | ユーザーID |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Score>](#score) | スコアのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeScores(
&ranking.DescribeScoresRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
ScorerUserId: pointy.String("user-0002"),
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeScoresRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeScores(
(new DescribeScoresRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withScorerUserId("user-0002")
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeScoresRequest;
import io.gs2.ranking.result.DescribeScoresResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeScoresResult result = client.describeScores(
new DescribeScoresRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0002")
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeScores(
new Gs2.Gs2Ranking.Request.DescribeScoresRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithScorerUserId("user-0002")
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeScores(
new Gs2Ranking.DescribeScoresRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0002")
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_scores(
ranking.DescribeScoresRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_scorer_user_id('user-0002')
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_scores({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0002",
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_scores_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0002",
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeScoresByUserId
ユーザーIDを指定してスコアの一覧を取得
指定したユーザーにおいて、指定したカテゴリで指定したスコア投稿者が登録したスコアのリストをページネーション付きで取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| scorerUserId | string | | ✓| | ~ 128文字 | ユーザーID |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Score>](#score) | スコアのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeScoresByUserId(
&ranking.DescribeScoresByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
ScorerUserId: pointy.String("user-0002"),
PageToken: nil,
Limit: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeScoresByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeScoresByUserId(
(new DescribeScoresByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withScorerUserId("user-0002")
->withPageToken(null)
->withLimit(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeScoresByUserIdRequest;
import io.gs2.ranking.result.DescribeScoresByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeScoresByUserIdResult result = client.describeScoresByUserId(
new DescribeScoresByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0002")
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeScoresByUserId(
new Gs2.Gs2Ranking.Request.DescribeScoresByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithScorerUserId("user-0002")
.WithPageToken(null)
.WithLimit(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeScoresByUserId(
new Gs2Ranking.DescribeScoresByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0002")
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_scores_by_user_id(
ranking.DescribeScoresByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_scorer_user_id('user-0002')
.with_page_token(None)
.with_limit(None)
.with_time_offset_token(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_scores_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0002",
pageToken=nil,
limit=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_scores_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0002",
pageToken=nil,
limit=nil,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### getScore
スコアを取得
カテゴリ、スコア投稿者のユーザーID、ユニークIDを指定して特定のスコアレコードを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリー名 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| scorerUserId | string | | ✓| | ~ 128文字 | ユーザーID |
| uniqueId | string | | | "0" | ~ 36文字 | スコアのユニークID |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Score](#score) | スコア |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetScore(
&ranking.GetScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
ScorerUserId: pointy.String("user-0002"),
UniqueId: pointy.String("unique-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getScore(
(new GetScoreRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withScorerUserId("user-0002")
->withUniqueId("unique-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetScoreRequest;
import io.gs2.ranking.result.GetScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetScoreResult result = client.getScore(
new GetScoreRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0002")
.withUniqueId("unique-0001")
);
Score item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetScore(
new Gs2.Gs2Ranking.Request.GetScoreRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithScorerUserId("user-0002")
.WithUniqueId("unique-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getScore(
new Gs2Ranking.GetScoreRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0002")
.withUniqueId("unique-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_score(
ranking.GetScoreRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_scorer_user_id('user-0002')
.with_unique_id('unique-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_score({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0002",
uniqueId="unique-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_score_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0002",
uniqueId="unique-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getScoreByUserId
ユーザーIDを指定してスコアを取得
指定したユーザーにおいて、カテゴリ、スコア投稿者のユーザーID、ユニークIDを指定して特定のスコアレコードを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリー名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| scorerUserId | string | | ✓| | ~ 128文字 | ユーザーID |
| uniqueId | string | | | "0" | ~ 36文字 | スコアのユニークID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Score](#score) | スコア |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetScoreByUserId(
&ranking.GetScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
ScorerUserId: pointy.String("user-0002"),
UniqueId: pointy.String("unique-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getScoreByUserId(
(new GetScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withScorerUserId("user-0002")
->withUniqueId("unique-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetScoreByUserIdRequest;
import io.gs2.ranking.result.GetScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetScoreByUserIdResult result = client.getScoreByUserId(
new GetScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0002")
.withUniqueId("unique-0001")
.withTimeOffsetToken(null)
);
Score item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetScoreByUserId(
new Gs2.Gs2Ranking.Request.GetScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithScorerUserId("user-0002")
.WithUniqueId("unique-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getScoreByUserId(
new Gs2Ranking.GetScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0002")
.withUniqueId("unique-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_score_by_user_id(
ranking.GetScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_scorer_user_id('user-0002')
.with_unique_id('unique-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_score_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0002",
uniqueId="unique-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_score_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0002",
uniqueId="unique-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeRankings
ランキングを取得
指定したカテゴリのランキングをページネーション付きで取得します。グローバルランキングとスコープ付きランキングの両方に対応しています。開始インデックスを指定して特定の順位から取得を開始できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | | | ~ 128文字 | アクセストークン |
| additionalScopeName | string | | | | ~ 128文字 | スコープ名
カテゴリー内でこの集計スコープを一意に識別する名前。
複数の期間限定ランキングボードを区別するために使用されます（例: "daily", "weekly"）。最大128文字。 |
| startIndex | long | | | | 0 ~ 9223372036854775805 | ランキングの取得を開始するインデックス |
| pageToken | string | | | | ~ 4096文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Ranking>](#ranking) | ランキングのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeRankings(
&ranking.DescribeRankingsRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
AdditionalScopeName: nil,
StartIndex: pointy.Int64(0),
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeRankingsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeRankings(
(new DescribeRankingsRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withAdditionalScopeName(null)
->withStartIndex(0)
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeRankingsRequest;
import io.gs2.ranking.result.DescribeRankingsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeRankingsResult result = client.describeRankings(
new DescribeRankingsRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withAdditionalScopeName(null)
.withStartIndex(0L)
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeRankings(
new Gs2.Gs2Ranking.Request.DescribeRankingsRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithAdditionalScopeName(null)
.WithStartIndex(0L)
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeRankings(
new Gs2Ranking.DescribeRankingsRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withAdditionalScopeName(null)
.withStartIndex(0)
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_rankings(
ranking.DescribeRankingsRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_additional_scope_name(None)
.with_start_index(0)
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_rankings({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
additionalScopeName=nil,
startIndex=0,
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_rankings_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
additionalScopeName=nil,
startIndex=0,
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeRankingssByUserId
ユーザーIDを指定してランキングを取得
指定したカテゴリとユーザーのランキングをページネーション付きで取得します。グローバルランキングとスコープ付きランキングの両方に対応しています。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | | | ~ 128文字 | ユーザーID |
| additionalScopeName | string | | | | ~ 128文字 | スコープ名
カテゴリー内でこの集計スコープを一意に識別する名前。
複数の期間限定ランキングボードを区別するために使用されます（例: "daily", "weekly"）。最大128文字。 |
| startIndex | long | | | | 0 ~ 9223372036854775805 | ランキングの取得を開始するインデックス |
| pageToken | string | | | | ~ 4096文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Ranking>](#ranking) | ランキングのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeRankingssByUserId(
&ranking.DescribeRankingssByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
AdditionalScopeName: nil,
StartIndex: pointy.Int64(0),
PageToken: nil,
Limit: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeRankingssByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeRankingssByUserId(
(new DescribeRankingssByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withAdditionalScopeName(null)
->withStartIndex(0)
->withPageToken(null)
->withLimit(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeRankingssByUserIdRequest;
import io.gs2.ranking.result.DescribeRankingssByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeRankingssByUserIdResult result = client.describeRankingssByUserId(
new DescribeRankingssByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withAdditionalScopeName(null)
.withStartIndex(0L)
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeRankingssByUserId(
new Gs2.Gs2Ranking.Request.DescribeRankingssByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithAdditionalScopeName(null)
.WithStartIndex(0L)
.WithPageToken(null)
.WithLimit(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeRankingssByUserId(
new Gs2Ranking.DescribeRankingssByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withAdditionalScopeName(null)
.withStartIndex(0)
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_rankingss_by_user_id(
ranking.DescribeRankingssByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_additional_scope_name(None)
.with_start_index(0)
.with_page_token(None)
.with_limit(None)
.with_time_offset_token(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_rankingss_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
additionalScopeName=nil,
startIndex=0,
pageToken=nil,
limit=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_rankingss_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
additionalScopeName=nil,
startIndex=0,
pageToken=nil,
limit=nil,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeNearRankings
指定したスコア付近のランキングを取得
このAPIはグローバルランキングのときのみ使用できます
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| additionalScopeName | string | | | | ~ 128文字 | スコープ名
カテゴリー内でこの集計スコープを一意に識別する名前。
複数の期間限定ランキングボードを区別するために使用されます（例: "daily", "weekly"）。最大128文字。 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | スコア
このランキングエントリのスコア値。
合算モードの場合、登録された全スコアの累積合計です。ランキングのソート順に使用される値はカテゴリーの orderDirection 設定に依存します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Ranking>](#ranking) | ランキングのリスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeNearRankings(
&ranking.DescribeNearRankingsRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AdditionalScopeName: nil,
Score: pointy.Int64(1000),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeNearRankingsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeNearRankings(
(new DescribeNearRankingsRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAdditionalScopeName(null)
->withScore(1000)
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeNearRankingsRequest;
import io.gs2.ranking.result.DescribeNearRankingsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeNearRankingsResult result = client.describeNearRankings(
new DescribeNearRankingsRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAdditionalScopeName(null)
.withScore(1000L)
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNearRankings(
new Gs2.Gs2Ranking.Request.DescribeNearRankingsRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAdditionalScopeName(null)
.WithScore(1000L),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeNearRankings(
new Gs2Ranking.DescribeNearRankingsRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAdditionalScopeName(null)
.withScore(1000)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_near_rankings(
ranking.DescribeNearRankingsRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_additional_scope_name(None)
.with_score(1000)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_near_rankings({
namespaceName="namespace-0001",
categoryName="category-0001",
additionalScopeName=nil,
score=1000,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_near_rankings_async({
namespaceName="namespace-0001",
categoryName="category-0001",
additionalScopeName=nil,
score=1000,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### getRanking
ランキングを取得
特定のスコア投稿者のスコアに対するランキング情報（順位を含む）を取得します。指定したスコア付近のランキングも合わせて返します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| scorerUserId | string | | ✓| | ~ 128文字 | スコアを獲得したユーザーのユーザーID |
| uniqueId | string | | | "0" | ~ 36文字 | スコアのユニークID |
| additionalScopeName | string | | | | ~ 128文字 | スコープ名
カテゴリー内でこの集計スコープを一意に識別する名前。
複数の期間限定ランキングボードを区別するために使用されます（例: "daily", "weekly"）。最大128文字。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Ranking](#ranking) | ランキング |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetRanking(
&ranking.GetRankingRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
ScorerUserId: pointy.String("user-0001"),
UniqueId: pointy.String("unique-id"),
AdditionalScopeName: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetRankingRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getRanking(
(new GetRankingRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withScorerUserId("user-0001")
->withUniqueId("unique-id")
->withAdditionalScopeName(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetRankingRequest;
import io.gs2.ranking.result.GetRankingResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetRankingResult result = client.getRanking(
new GetRankingRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0001")
.withUniqueId("unique-id")
.withAdditionalScopeName(null)
);
Ranking item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetRanking(
new Gs2.Gs2Ranking.Request.GetRankingRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithScorerUserId("user-0001")
.WithUniqueId("unique-id")
.WithAdditionalScopeName(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getRanking(
new Gs2Ranking.GetRankingRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0001")
.withUniqueId("unique-id")
.withAdditionalScopeName(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_ranking(
ranking.GetRankingRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_scorer_user_id('user-0001')
.with_unique_id('unique-id')
.with_additional_scope_name(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_ranking({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0001",
uniqueId="unique-id",
additionalScopeName=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_ranking_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0001",
uniqueId="unique-id",
additionalScopeName=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getRankingByUserId
ユーザーIDを指定してランキングを取得
指定したユーザーにおける特定のスコア投稿者のスコアに対するランキング情報（順位を含む）を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ランキングを取得するユーザーID（GS2-Schedule の期間判定に使用されます。） |
| scorerUserId | string | | ✓| | ~ 128文字 | スコアを獲得したユーザーのユーザーID |
| uniqueId | string | | | "0" | ~ 36文字 | スコアのユニークID |
| additionalScopeName | string | | | | ~ 128文字 | スコープ名
カテゴリー内でこの集計スコープを一意に識別する名前。
複数の期間限定ランキングボードを区別するために使用されます（例: "daily", "weekly"）。最大128文字。 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Ranking](#ranking) | ランキング |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetRankingByUserId(
&ranking.GetRankingByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
ScorerUserId: pointy.String("user-0001"),
UniqueId: pointy.String("unique-id"),
AdditionalScopeName: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetRankingByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getRankingByUserId(
(new GetRankingByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withScorerUserId("user-0001")
->withUniqueId("unique-id")
->withAdditionalScopeName(null)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetRankingByUserIdRequest;
import io.gs2.ranking.result.GetRankingByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetRankingByUserIdResult result = client.getRankingByUserId(
new GetRankingByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0001")
.withUniqueId("unique-id")
.withAdditionalScopeName(null)
.withTimeOffsetToken(null)
);
Ranking item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetRankingByUserId(
new Gs2.Gs2Ranking.Request.GetRankingByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithScorerUserId("user-0001")
.WithUniqueId("unique-id")
.WithAdditionalScopeName(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getRankingByUserId(
new Gs2Ranking.GetRankingByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0001")
.withUniqueId("unique-id")
.withAdditionalScopeName(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_ranking_by_user_id(
ranking.GetRankingByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_scorer_user_id('user-0001')
.with_unique_id('unique-id')
.with_additional_scope_name(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_ranking_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0001",
uniqueId="unique-id",
additionalScopeName=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_ranking_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0001",
uniqueId="unique-id",
additionalScopeName=nil,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### putScore
スコアを登録
指定したランキングカテゴリにリクエストしたユーザーのスコアを登録します。カテゴリのタイプに応じてグローバルランキングまたはスコープ付きランキングの処理に振り分けられます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| score | long | | ✓| | 0 ~ 9223372036854775805 | スコア
このランキングエントリのスコア値。
合算モードの場合、登録された全スコアの累積合計です。ランキングのソート順に使用される値はカテゴリーの orderDirection 設定に依存します。 |
| metadata | string | | | | ~ 512文字 | メタデータ
このランキングエントリに関連付けられた任意のメタデータ。
スコア登録時に設定され、ランキング結果と共に返されます。最大512文字。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Score](#score) | 登録したスコア |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.PutScore(
&ranking.PutScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
Score: pointy.Int64(1000),
Metadata: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\PutScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->putScore(
(new PutScoreRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withScore(1000)
->withMetadata(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.PutScoreRequest;
import io.gs2.ranking.result.PutScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
PutScoreResult result = client.putScore(
new PutScoreRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScore(1000L)
.withMetadata(null)
);
Score item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.PutScore(
new Gs2.Gs2Ranking.Request.PutScoreRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithScore(1000L)
.WithMetadata(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.putScore(
new Gs2Ranking.PutScoreRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScore(1000)
.withMetadata(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.put_score(
ranking.PutScoreRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_score(1000)
.with_metadata(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.put_score({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
score=1000,
metadata=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.put_score_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
score=1000,
metadata=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### putScoreByUserId
ユーザーIDを指定してスコアを登録
指定したランキングカテゴリに指定したユーザーのスコアを登録します。カテゴリのタイプに応じてグローバルランキングまたはスコープ付きランキングの処理に振り分けられます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| score | long | | ✓| | 0 ~ 9223372036854775805 | スコア
このランキングエントリのスコア値。
合算モードの場合、登録された全スコアの累積合計です。ランキングのソート順に使用される値はカテゴリーの orderDirection 設定に依存します。 |
| metadata | string | | | | ~ 512文字 | メタデータ
このランキングエントリに関連付けられた任意のメタデータ。
スコア登録時に設定され、ランキング結果と共に返されます。最大512文字。 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Score](#score) | 登録したスコア |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.PutScoreByUserId(
&ranking.PutScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
Score: pointy.Int64(1000),
Metadata: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\PutScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->putScoreByUserId(
(new PutScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withScore(1000)
->withMetadata(null)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.PutScoreByUserIdRequest;
import io.gs2.ranking.result.PutScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
PutScoreByUserIdResult result = client.putScoreByUserId(
new PutScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScore(1000L)
.withMetadata(null)
.withTimeOffsetToken(null)
);
Score item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.PutScoreByUserId(
new Gs2.Gs2Ranking.Request.PutScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithScore(1000L)
.WithMetadata(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.putScoreByUserId(
new Gs2Ranking.PutScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScore(1000)
.withMetadata(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.put_score_by_user_id(
ranking.PutScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_score(1000)
.with_metadata(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.put_score_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
score=1000,
metadata=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.put_score_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
score=1000,
metadata=nil,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### calcRanking
ランキングの計算処理の強制実行
スケジュールされた計算タイミングに関係なく、指定したカテゴリのランキング再計算を即座に実行します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名 |
| additionalScopeName | string | | | | ~ 128文字 | 追加のスコープ |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| processing | bool | 非同期処理で集計処理が継続中か |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CalcRanking(
&ranking.CalcRankingRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AdditionalScopeName: nil,
}
)
if err != nil {
panic("error occurred")
}
processing := result.Processing
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CalcRankingRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->calcRanking(
(new CalcRankingRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAdditionalScopeName(null)
);
$processing = $result->getProcessing();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CalcRankingRequest;
import io.gs2.ranking.result.CalcRankingResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
CalcRankingResult result = client.calcRanking(
new CalcRankingRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAdditionalScopeName(null)
);
boolean processing = result.getProcessing();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CalcRanking(
new Gs2.Gs2Ranking.Request.CalcRankingRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAdditionalScopeName(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var processing = result.Processing;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.calcRanking(
new Gs2Ranking.CalcRankingRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAdditionalScopeName(null)
);
const processing = result.getProcessing();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.calc_ranking(
ranking.CalcRankingRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_additional_scope_name(None)
)
processing = result.processing
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.calc_ranking({
namespaceName="namespace-0001",
categoryName="category-0001",
additionalScopeName=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
processing = result.processing;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.calc_ranking_async({
namespaceName="namespace-0001",
categoryName="category-0001",
additionalScopeName=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
processing = result.processing;
```
---
### getSubscribe
購読対象ユーザー情報を取得
指定したランキングカテゴリにおける特定の対象ユーザーの購読情報を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリー名 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| targetUserId | string | | ✓| | ~ 128文字 | ユーザーID |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 購読対象ユーザー情報 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetSubscribe(
&ranking.GetSubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
TargetUserId: pointy.String("user-0002"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetSubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getSubscribe(
(new GetSubscribeRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withTargetUserId("user-0002")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetSubscribeRequest;
import io.gs2.ranking.result.GetSubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetSubscribeResult result = client.getSubscribe(
new GetSubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
SubscribeUser item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribe(
new Gs2.Gs2Ranking.Request.GetSubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithTargetUserId("user-0002"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getSubscribe(
new Gs2Ranking.GetSubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_subscribe(
ranking.GetSubscribeRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_target_user_id('user-0002')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_subscribe({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_subscribe_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getSubscribeByUserId
ユーザーIDを指定して購読を取得
指定したユーザーにおける、指定したランキングカテゴリの特定の対象ユーザーの購読情報を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリー名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| targetUserId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 購読対象ユーザー情報 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetSubscribeByUserId(
&ranking.GetSubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
TargetUserId: pointy.String("user-0002"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetSubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getSubscribeByUserId(
(new GetSubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withTargetUserId("user-0002")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetSubscribeByUserIdRequest;
import io.gs2.ranking.result.GetSubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetSubscribeByUserIdResult result = client.getSubscribeByUserId(
new GetSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
SubscribeUser item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribeByUserId(
new Gs2.Gs2Ranking.Request.GetSubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithTargetUserId("user-0002")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getSubscribeByUserId(
new Gs2Ranking.GetSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_subscribe_by_user_id(
ranking.GetSubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_target_user_id('user-0002')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_subscribe_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
targetUserId="user-0002",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_subscribe_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
targetUserId="user-0002",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### unsubscribe
対象ユーザーの購読を解除
指定したカテゴリにおいて、指定した対象ユーザーのランキング購読を解除します。対象ユーザーのスコアはリクエストしたユーザーのスコープ付きランキングに表示されなくなります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリー名 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| targetUserId | string | | ✓| | ~ 128文字 | 購読解除するユーザーID |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 解除した購読対象ユーザー情報 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.Unsubscribe(
&ranking.UnsubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
TargetUserId: pointy.String("user-0002"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UnsubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->unsubscribe(
(new UnsubscribeRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withTargetUserId("user-0002")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UnsubscribeRequest;
import io.gs2.ranking.result.UnsubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UnsubscribeResult result = client.unsubscribe(
new UnsubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
SubscribeUser item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.Unsubscribe(
new Gs2.Gs2Ranking.Request.UnsubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithTargetUserId("user-0002"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.unsubscribe(
new Gs2Ranking.UnsubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.unsubscribe(
ranking.UnsubscribeRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_target_user_id('user-0002')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.unsubscribe({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.unsubscribe_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### unsubscribeByUserId
ユーザーIDを指定して対象ユーザーの購読を解除
指定したユーザーに代わって、指定したカテゴリにおいて指定した対象ユーザーのランキング購読を解除します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリー名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| targetUserId | string | | ✓| | ~ 128文字 | 購読解除するユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 解除した購読対象ユーザー情報 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.UnsubscribeByUserId(
&ranking.UnsubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
TargetUserId: pointy.String("user-0002"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UnsubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->unsubscribeByUserId(
(new UnsubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withTargetUserId("user-0002")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UnsubscribeByUserIdRequest;
import io.gs2.ranking.result.UnsubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UnsubscribeByUserIdResult result = client.unsubscribeByUserId(
new UnsubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
SubscribeUser item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.UnsubscribeByUserId(
new Gs2.Gs2Ranking.Request.UnsubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithTargetUserId("user-0002")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.unsubscribeByUserId(
new Gs2Ranking.UnsubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.unsubscribe_by_user_id(
ranking.UnsubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_target_user_id('user-0002')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.unsubscribe_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
targetUserId="user-0002",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.unsubscribe_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
targetUserId="user-0002",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeSubscribesByCategoryName
購読しているユーザーのユーザーIDの一覧取得
指定したランキングカテゴリにおいて、リクエストしたユーザーが購読しているユーザーの一覧を取得します。購読ユーザーのスコアはスコープ付きランキングに含まれます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<SubscribeUser>](#subscribeuser) | 購読対象ユーザー情報のリスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeSubscribesByCategoryName(
&ranking.DescribeSubscribesByCategoryNameRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeSubscribesByCategoryNameRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeSubscribesByCategoryName(
(new DescribeSubscribesByCategoryNameRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeSubscribesByCategoryNameRequest;
import io.gs2.ranking.result.DescribeSubscribesByCategoryNameResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeSubscribesByCategoryNameResult result = client.describeSubscribesByCategoryName(
new DescribeSubscribesByCategoryNameRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribesByCategoryName(
new Gs2.Gs2Ranking.Request.DescribeSubscribesByCategoryNameRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeSubscribesByCategoryName(
new Gs2Ranking.DescribeSubscribesByCategoryNameRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_subscribes_by_category_name(
ranking.DescribeSubscribesByCategoryNameRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_subscribes_by_category_name({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_subscribes_by_category_name_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describeSubscribesByCategoryNameAndUserId
ユーザーIDを指定してそのユーザーが購読しているユーザーの一覧取得
指定したランキングカテゴリにおいて、指定したユーザーが購読しているユーザーの一覧を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<SubscribeUser>](#subscribeuser) | 購読対象ユーザー情報のリスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeSubscribesByCategoryNameAndUserId(
&ranking.DescribeSubscribesByCategoryNameAndUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeSubscribesByCategoryNameAndUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeSubscribesByCategoryNameAndUserId(
(new DescribeSubscribesByCategoryNameAndUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeSubscribesByCategoryNameAndUserIdRequest;
import io.gs2.ranking.result.DescribeSubscribesByCategoryNameAndUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeSubscribesByCategoryNameAndUserIdResult result = client.describeSubscribesByCategoryNameAndUserId(
new DescribeSubscribesByCategoryNameAndUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribesByCategoryNameAndUserId(
new Gs2.Gs2Ranking.Request.DescribeSubscribesByCategoryNameAndUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeSubscribesByCategoryNameAndUserId(
new Gs2Ranking.DescribeSubscribesByCategoryNameAndUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_subscribes_by_category_name_and_user_id(
ranking.DescribeSubscribesByCategoryNameAndUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_time_offset_token(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_subscribes_by_category_name_and_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_subscribes_by_category_name_and_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describeCategoryModels
カテゴリモデルの一覧を取得
現在アクティブなカテゴリモデルの一覧を取得します。カテゴリモデルはスコアリングルール、計算設定、スコープ設定を含むランキングカテゴリを定義します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<CategoryModel>](#categorymodel) | カテゴリモデルのリスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeCategoryModels(
&ranking.DescribeCategoryModelsRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeCategoryModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeCategoryModels(
(new DescribeCategoryModelsRequest())
->withNamespaceName("namespace-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeCategoryModelsRequest;
import io.gs2.ranking.result.DescribeCategoryModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeCategoryModelsResult result = client.describeCategoryModels(
new DescribeCategoryModelsRequest()
.withNamespaceName("namespace-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCategoryModels(
new Gs2.Gs2Ranking.Request.DescribeCategoryModelsRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeCategoryModels(
new Gs2Ranking.DescribeCategoryModelsRequest()
.withNamespaceName("namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_category_models(
ranking.DescribeCategoryModelsRequest()
.with_namespace_name('namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_category_models({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_category_models_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### getCategoryModel
カテゴリモデルを取得
スコア範囲、ソート順、スコープタイプ、グローバルランキング設定、エントリー/アクセス期間イベント設定を含む、指定されたカテゴリモデルを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CategoryModel](#categorymodel) | カテゴリモデル |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetCategoryModel(
&ranking.GetCategoryModelRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetCategoryModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getCategoryModel(
(new GetCategoryModelRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetCategoryModelRequest;
import io.gs2.ranking.result.GetCategoryModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetCategoryModelResult result = client.getCategoryModel(
new GetCategoryModelRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
CategoryModel item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCategoryModel(
new Gs2.Gs2Ranking.Request.GetCategoryModelRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getCategoryModel(
new Gs2Ranking.GetCategoryModelRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_category_model(
ranking.GetCategoryModelRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_category_model({
namespaceName="namespace-0001",
categoryName="category-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_category_model_async({
namespaceName="namespace-0001",
categoryName="category-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### exportMaster
モデルマスターを有効化可能なマスターデータ形式でエクスポート
現在登録されているカテゴリモデルマスターを有効化可能なマスターデータ形式でエクスポートします。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentRankingMaster](#currentrankingmaster) | 有効化可能なマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.ExportMaster(
&ranking.ExportMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\ExportMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->exportMaster(
(new ExportMasterRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.ExportMasterRequest;
import io.gs2.ranking.result.ExportMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
ExportMasterResult result = client.exportMaster(
new ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentRankingMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExportMaster(
new Gs2.Gs2Ranking.Request.ExportMasterRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.exportMaster(
new Gs2Ranking.ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.export_master(
ranking.ExportMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.export_master({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.export_master_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getCurrentRankingMaster
現在アクティブなランキングモデルのマスターデータを取得
カテゴリモデル定義を含む、現在アクティブなランキングモデルのマスターデータを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentRankingMaster](#currentrankingmaster) | 現在アクティブなランキングモデルのマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetCurrentRankingMaster(
&ranking.GetCurrentRankingMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetCurrentRankingMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getCurrentRankingMaster(
(new GetCurrentRankingMasterRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetCurrentRankingMasterRequest;
import io.gs2.ranking.result.GetCurrentRankingMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetCurrentRankingMasterResult result = client.getCurrentRankingMaster(
new GetCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentRankingMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCurrentRankingMaster(
new Gs2.Gs2Ranking.Request.GetCurrentRankingMasterRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getCurrentRankingMaster(
new Gs2Ranking.GetCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_current_ranking_master(
ranking.GetCurrentRankingMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_current_ranking_master({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_current_ranking_master_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### preUpdateCurrentRankingMaster
現在アクティブなランキングモデルのマスターデータを更新（3フェーズ版）
1MBを超えるマスターデータをアップロードする場合は、3フェーズで更新を行います。
1. このAPIを実行し、アップロード用のトークンとURLを取得します。
2. 取得したURLに対して、マスターデータをアップロードします。
3. UpdateCurrentRankingMaster にアップロードで取得したトークンを渡して実行し、マスターデータを反映します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| uploadToken | string | アップロード後に結果を反映する際に使用するトークン |
| uploadUrl | string | アップロード処理の実行に使用するURL |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.PreUpdateCurrentRankingMaster(
&ranking.PreUpdateCurrentRankingMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\PreUpdateCurrentRankingMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->preUpdateCurrentRankingMaster(
(new PreUpdateCurrentRankingMasterRequest())
->withNamespaceName("namespace-0001")
);
$uploadToken = $result->getUploadToken();
$uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.PreUpdateCurrentRankingMasterRequest;
import io.gs2.ranking.result.PreUpdateCurrentRankingMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
PreUpdateCurrentRankingMasterResult result = client.preUpdateCurrentRankingMaster(
new PreUpdateCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
);
String uploadToken = result.getUploadToken();
String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.PreUpdateCurrentRankingMaster(
new Gs2.Gs2Ranking.Request.PreUpdateCurrentRankingMasterRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var uploadUrl = result.UploadUrl;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.preUpdateCurrentRankingMaster(
new Gs2Ranking.PreUpdateCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
);
const uploadToken = result.getUploadToken();
const uploadUrl = result.getUploadUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.pre_update_current_ranking_master(
ranking.PreUpdateCurrentRankingMasterRequest()
.with_namespace_name('namespace-0001')
)
upload_token = result.upload_token
upload_url = result.upload_url
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.pre_update_current_ranking_master({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.pre_update_current_ranking_master_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
---
### updateCurrentRankingMaster
現在アクティブなランキングモデルのマスターデータを更新
現在アクティブなランキングモデルのマスターデータを更新します。大容量マスターデータに対応するため、直接更新モードと事前アップロードモードの両方をサポートしています。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| mode | 文字列列挙型
enum {
"direct",
"preUpload"
}
| | | "direct" | | 更新モード"direct": マスターデータを直接更新 / "preUpload": マスターデータをアップロードしてから更新 / |
| settings | string | {mode} == "direct" | ✓※| | ~ 5242880 バイト (5MB) | マスターデータ
※ mode が "direct" であれば必須 |
| uploadToken | string | {mode} == "preUpload" | ✓※| | ~ 1024文字 | 事前アップロードで取得したトークン
アップロードしたマスターデータを適用するために使用されます。
※ mode が "preUpload" であれば必須 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentRankingMaster](#currentrankingmaster) | 更新された現在アクティブなランキングモデルのマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.UpdateCurrentRankingMaster(
&ranking.UpdateCurrentRankingMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Mode: pointy.String("direct"),
Settings: pointy.String("{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}"),
UploadToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UpdateCurrentRankingMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->updateCurrentRankingMaster(
(new UpdateCurrentRankingMasterRequest())
->withNamespaceName("namespace-0001")
->withMode("direct")
->withSettings("{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}")
->withUploadToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UpdateCurrentRankingMasterRequest;
import io.gs2.ranking.result.UpdateCurrentRankingMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UpdateCurrentRankingMasterResult result = client.updateCurrentRankingMaster(
new UpdateCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}")
.withUploadToken(null)
);
CurrentRankingMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentRankingMaster(
new Gs2.Gs2Ranking.Request.UpdateCurrentRankingMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMode("direct")
.WithSettings("{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}")
.WithUploadToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.updateCurrentRankingMaster(
new Gs2Ranking.UpdateCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}")
.withUploadToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.update_current_ranking_master(
ranking.UpdateCurrentRankingMasterRequest()
.with_namespace_name('namespace-0001')
.with_mode('direct')
.with_settings('{\n "version": "2019-09-17",\n "categoryModels": [\n {\n "name": "category-0001",\n "orderDirection": "asc",\n "scope": "global",\n "uniqueByUserId": false,\n "sum": false,\n "calculateFixedTimingHour": -1,\n "calculateFixedTimingMinute": 0,\n "calculateIntervalMinutes": 15,\n "additionalScopes": [\n {\n "name": "daily",\n "targetDays": 1\n },\n {\n "name": "weekly",\n "targetDays": 7\n }\n ],\n "ignoreUserIds": []\n },\n {\n "name": "category-0002",\n "metadata": "CATEGORY_0002",\n "minimumValue": 1000,\n "maximumValue": 100000,\n "orderDirection": "asc",\n "scope": "scoped",\n "uniqueByUserId": true,\n "sum": false,\n "calculateFixedTimingHour": -1,\n "calculateFixedTimingMinute": 0,\n "calculateIntervalMinutes": 60,\n "additionalScopes": [],\n "ignoreUserIds": []\n }\n ]\n}')
.with_upload_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.update_current_ranking_master({
namespaceName="namespace-0001",
mode="direct",
settings="{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}",
uploadToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.update_current_ranking_master_async({
namespaceName="namespace-0001",
mode="direct",
settings="{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}",
uploadToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateCurrentRankingMasterFromGitHub
現在アクティブなランキングモデルのマスターデータをGitHubから更新
指定されたチェックアウト設定を使用して GitHub リポジトリからマスターデータをチェックアウトし、現在アクティブなランキングモデルのマスターデータを更新します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| checkoutSetting | [GitHubCheckoutSetting](#githubcheckoutsetting) | | ✓| | | GitHubからマスターデータをチェックアウトする設定 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentRankingMaster](#currentrankingmaster) | 更新された現在アクティブなランキングモデルのマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.UpdateCurrentRankingMasterFromGitHub(
&ranking.UpdateCurrentRankingMasterFromGitHubRequest {
NamespaceName: pointy.String("namespace-0001"),
CheckoutSetting: &ranking.GitHubCheckoutSetting{
ApiKeyId: pointy.String("apiKeyId-0001"),
RepositoryName: pointy.String("gs2io/master-data"),
SourcePath: pointy.String("path/to/file.json"),
ReferenceType: pointy.String("branch"),
BranchName: pointy.String("develop"),
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UpdateCurrentRankingMasterFromGitHubRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->updateCurrentRankingMasterFromGitHub(
(new UpdateCurrentRankingMasterFromGitHubRequest())
->withNamespaceName("namespace-0001")
->withCheckoutSetting((new GitHubCheckoutSetting())
->withApiKeyId("apiKeyId-0001")
->withRepositoryName("gs2io/master-data")
->withSourcePath("path/to/file.json")
->withReferenceType("branch")
->withBranchName("develop")
)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UpdateCurrentRankingMasterFromGitHubRequest;
import io.gs2.ranking.result.UpdateCurrentRankingMasterFromGitHubResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UpdateCurrentRankingMasterFromGitHubResult result = client.updateCurrentRankingMasterFromGitHub(
new UpdateCurrentRankingMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
CurrentRankingMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentRankingMasterFromGitHub(
new Gs2.Gs2Ranking.Request.UpdateCurrentRankingMasterFromGitHubRequest()
.WithNamespaceName("namespace-0001")
.WithCheckoutSetting(new Gs2.Gs2Ranking.Model.GitHubCheckoutSetting()
.WithApiKeyId("apiKeyId-0001")
.WithRepositoryName("gs2io/master-data")
.WithSourcePath("path/to/file.json")
.WithReferenceType("branch")
.WithBranchName("develop")
),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.updateCurrentRankingMasterFromGitHub(
new Gs2Ranking.UpdateCurrentRankingMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new Gs2Ranking.model.GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.update_current_ranking_master_from_git_hub(
ranking.UpdateCurrentRankingMasterFromGitHubRequest()
.with_namespace_name('namespace-0001')
.with_checkout_setting(ranking.GitHubCheckoutSetting()
.with_api_key_id('apiKeyId-0001')
.with_repository_name('gs2io/master-data')
.with_source_path('path/to/file.json')
.with_reference_type('branch')
.with_branch_name('develop')
)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.update_current_ranking_master_from_git_hub({
namespaceName="namespace-0001",
checkoutSetting={
api_key_id="apiKeyId-0001",
repository_name="gs2io/master-data",
source_path="path/to/file.json",
reference_type="branch",
branch_name="develop",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.update_current_ranking_master_from_git_hub_async({
namespaceName="namespace-0001",
checkoutSetting={
api_key_id="apiKeyId-0001",
repository_name="gs2io/master-data",
source_path="path/to/file.json",
reference_type="branch",
branch_name="develop",
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeCategoryModelMasters
カテゴリモデルマスターの一覧を取得
カテゴリモデルマスターのページネーション付きリストを取得します。名前のプレフィックスでフィルタリングできます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| namePrefix | string | | | | ~ 64文字 | カテゴリモデル名のフィルター接頭辞 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<CategoryModelMaster>](#categorymodelmaster) | カテゴリモデルマスターのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeCategoryModelMasters(
&ranking.DescribeCategoryModelMastersRequest {
NamespaceName: pointy.String("namespace-0001"),
NamePrefix: nil,
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeCategoryModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeCategoryModelMasters(
(new DescribeCategoryModelMastersRequest())
->withNamespaceName("namespace-0001")
->withNamePrefix(null)
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeCategoryModelMastersRequest;
import io.gs2.ranking.result.DescribeCategoryModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeCategoryModelMastersResult result = client.describeCategoryModelMasters(
new DescribeCategoryModelMastersRequest()
.withNamespaceName("namespace-0001")
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCategoryModelMasters(
new Gs2.Gs2Ranking.Request.DescribeCategoryModelMastersRequest()
.WithNamespaceName("namespace-0001")
.WithNamePrefix(null)
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeCategoryModelMasters(
new Gs2Ranking.DescribeCategoryModelMastersRequest()
.withNamespaceName("namespace-0001")
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_category_model_masters(
ranking.DescribeCategoryModelMastersRequest()
.with_namespace_name('namespace-0001')
.with_name_prefix(None)
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_category_model_masters({
namespaceName="namespace-0001",
namePrefix=nil,
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_category_model_masters_async({
namespaceName="namespace-0001",
namePrefix=nil,
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createCategoryModelMaster
カテゴリモデルマスターを新規作成
スコア範囲、ソート順、スコープタイプ、グローバルランキング設定、エントリー/アクセス期間イベント設定を持つ新しいカテゴリモデルマスターを作成します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 1024文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | スコアの最小値
このカテゴリーに登録できるスコアの最小値。
この閾値を下回るスコアは登録時に拒否されます。未設定の場合、下限はありません。 |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | スコアの最大値
このカテゴリーに登録できるスコアの最大値。
この閾値を上回るスコアは登録時に拒否されます。未設定の場合、上限はありません。 |
| orderDirection | 文字列列挙型
enum {
"asc",
"desc"
}
| | ✓| | | ソート方向
ランキング集計のソート順を決定します。
"asc"（昇順）は低いスコアを上位とし、タイムベースやゴルフ式のランキングに適しています。
"desc"（降順）は高いスコアを上位とし、ポイントベースやハイスコアランキングに適しています。"asc": 昇順 / "desc": 降順 / |
| scope | 文字列列挙型
enum {
"global",
"scoped"
}
| | ✓| | | ランキングの種類
このカテゴリーのランキングタイプ。
"global" は全プレイヤーが共有する単一のリーダーボードを作成し、設定された間隔でバッチ集計されます。
"scoped" は購読したプレイヤー（フレンドやギルドメンバー等）に基づくユーザーごとのリーダーボードを作成し、スコアがリアルタイムで反映されます。"global": グローバル / "scoped": スコープ / |
| globalRankingSetting | [GlobalRankingSetting](#globalrankingsetting) | {scope} == "global" | ✓※| | | グローバルランキング設定
グローバルランキングモード固有の設定。集計間隔、固定時刻、スコアのユニーク性、世代管理、および追加の期間限定スコープを含みます。
scope が "global" に設定されている場合のみ適用されます。
※ scope が "global" であれば必須 |
| entryPeriodEventId | string | | | | ~ 1024文字 | スコア登録期間イベントID
スコア登録を受け付ける期間を定義する GS2-Schedule イベントの GRN。
この期間外のスコア登録リクエストは拒否されます。未設定の場合、スコアはいつでも登録できます。 |
| accessPeriodEventId | string | | | | ~ 1024文字 | アクセス期間イベントID
ランキングデータを閲覧できる期間を定義する GS2-Schedule イベントの GRN。
この期間外のランキング取得リクエストは拒否されます。未設定の場合、ランキングはいつでもアクセスできます。 |
| sum | bool | | | false | | 合算モード
有効にすると、新しく登録されたスコアは既存のスコアを置き換えるのではなく、合計に加算されます。
ランキングは蓄積された合計値に基づいて計算されます。無効の場合、各スコア登録は独立したエントリとして扱われます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | 作成したカテゴリモデルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CreateCategoryModelMaster(
&ranking.CreateCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("category-0001"),
Description: nil,
Metadata: nil,
MinimumValue: nil,
MaximumValue: nil,
OrderDirection: pointy.String("asc"),
Scope: pointy.String("global"),
GlobalRankingSetting: &ranking.GlobalRankingSetting{
CalculateIntervalMinutes: pointy.Int32(15),
UniqueByUserId: pointy.Bool(false),
AdditionalScopes: []ranking.Scope{
ranking.Scope{
Name: pointy.String("daily"),
TargetDays: pointy.Int64(1),
},
ranking.Scope{
Name: pointy.String("weekly"),
TargetDays: pointy.Int64(7),
},
},
},
EntryPeriodEventId: nil,
AccessPeriodEventId: nil,
Sum: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CreateCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->createCategoryModelMaster(
(new CreateCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withName("category-0001")
->withDescription(null)
->withMetadata(null)
->withMinimumValue(null)
->withMaximumValue(null)
->withOrderDirection("asc")
->withScope("global")
->withGlobalRankingSetting((new \Gs2\Ranking\Model\GlobalRankingSetting())
->withCalculateIntervalMinutes(15)
->withUniqueByUserId(false)
->withAdditionalScopes([
(new \Gs2\Ranking\Model\Scope())
->withName("daily")
->withTargetDays(1),
(new \Gs2\Ranking\Model\Scope())
->withName("weekly")
->withTargetDays(7),
]))
->withEntryPeriodEventId(null)
->withAccessPeriodEventId(null)
->withSum(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CreateCategoryModelMasterRequest;
import io.gs2.ranking.result.CreateCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
CreateCategoryModelMasterResult result = client.createCategoryModelMaster(
new CreateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("category-0001")
.withDescription(null)
.withMetadata(null)
.withMinimumValue(null)
.withMaximumValue(null)
.withOrderDirection("asc")
.withScope("global")
.withGlobalRankingSetting(new io.gs2.ranking.model.GlobalRankingSetting()
.withCalculateIntervalMinutes(15)
.withUniqueByUserId(false)
.withAdditionalScopes(Arrays.asList(
new io.gs2.ranking.model.Scope()
.withName("daily")
.withTargetDays(1L),
new io.gs2.ranking.model.Scope()
.withName("weekly")
.withTargetDays(7L)
)))
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
.withSum(null)
);
CategoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateCategoryModelMaster(
new Gs2.Gs2Ranking.Request.CreateCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("category-0001")
.WithDescription(null)
.WithMetadata(null)
.WithMinimumValue(null)
.WithMaximumValue(null)
.WithOrderDirection("asc")
.WithScope("global")
.WithGlobalRankingSetting(new Gs2.Gs2Ranking.Model.GlobalRankingSetting()
.WithCalculateIntervalMinutes(15)
.WithUniqueByUserId(false)
.WithAdditionalScopes(new Gs2.Gs2Ranking.Model.Scope[] {
new Gs2.Gs2Ranking.Model.Scope()
.WithName("daily")
.WithTargetDays(1L),
new Gs2.Gs2Ranking.Model.Scope()
.WithName("weekly")
.WithTargetDays(7L),
}))
.WithEntryPeriodEventId(null)
.WithAccessPeriodEventId(null)
.WithSum(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.createCategoryModelMaster(
new Gs2Ranking.CreateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("category-0001")
.withDescription(null)
.withMetadata(null)
.withMinimumValue(null)
.withMaximumValue(null)
.withOrderDirection("asc")
.withScope("global")
.withGlobalRankingSetting(new Gs2Ranking.model.GlobalRankingSetting()
.withCalculateIntervalMinutes(15)
.withUniqueByUserId(false)
.withAdditionalScopes([
new Gs2Ranking.model.Scope()
.withName("daily")
.withTargetDays(1),
new Gs2Ranking.model.Scope()
.withName("weekly")
.withTargetDays(7),
]))
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
.withSum(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.create_category_model_master(
ranking.CreateCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('category-0001')
.with_description(None)
.with_metadata(None)
.with_minimum_value(None)
.with_maximum_value(None)
.with_order_direction('asc')
.with_scope('global')
.with_global_ranking_setting(
ranking.GlobalRankingSetting()
.with_calculate_interval_minutes(15)
.with_unique_by_user_id(False)
.with_additional_scopes([
ranking.Scope()
.with_name('daily')
.with_target_days(1),
ranking.Scope()
.with_name('weekly')
.with_target_days(7),
]))
.with_entry_period_event_id(None)
.with_access_period_event_id(None)
.with_sum(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.create_category_model_master({
namespaceName="namespace-0001",
name="category-0001",
description=nil,
metadata=nil,
minimumValue=nil,
maximumValue=nil,
orderDirection="asc",
scope="global",
globalRankingSetting={
calculateIntervalMinutes=15,
uniqueByUserId=false,
additionalScopes={
{
name="daily",
targetDays=1,
},
{
name="weekly",
targetDays=7,
}
},
},
entryPeriodEventId=nil,
accessPeriodEventId=nil,
sum=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.create_category_model_master_async({
namespaceName="namespace-0001",
name="category-0001",
description=nil,
metadata=nil,
minimumValue=nil,
maximumValue=nil,
orderDirection="asc",
scope="global",
globalRankingSetting={
calculateIntervalMinutes=15,
uniqueByUserId=false,
additionalScopes={
{
name="daily",
targetDays=1,
},
{
name="weekly",
targetDays=7,
}
},
},
entryPeriodEventId=nil,
accessPeriodEventId=nil,
sum=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getCategoryModelMaster
カテゴリモデルマスターを取得
指定されたカテゴリモデルマスターを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | カテゴリモデルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetCategoryModelMaster(
&ranking.GetCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getCategoryModelMaster(
(new GetCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetCategoryModelMasterRequest;
import io.gs2.ranking.result.GetCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetCategoryModelMasterResult result = client.getCategoryModelMaster(
new GetCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
CategoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCategoryModelMaster(
new Gs2.Gs2Ranking.Request.GetCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getCategoryModelMaster(
new Gs2Ranking.GetCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_category_model_master(
ranking.GetCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_category_model_master({
namespaceName="namespace-0001",
categoryName="category-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_category_model_master_async({
namespaceName="namespace-0001",
categoryName="category-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateCategoryModelMaster
カテゴリモデルマスターを更新
指定されたカテゴリモデルマスターのスコア範囲、ソート順、スコープタイプ、グローバルランキング設定、エントリー/アクセス期間イベント設定を更新します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 1024文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | スコアの最小値
このカテゴリーに登録できるスコアの最小値。
この閾値を下回るスコアは登録時に拒否されます。未設定の場合、下限はありません。 |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | スコアの最大値
このカテゴリーに登録できるスコアの最大値。
この閾値を上回るスコアは登録時に拒否されます。未設定の場合、上限はありません。 |
| orderDirection | 文字列列挙型
enum {
"asc",
"desc"
}
| | ✓| | | ソート方向
ランキング集計のソート順を決定します。
"asc"（昇順）は低いスコアを上位とし、タイムベースやゴルフ式のランキングに適しています。
"desc"（降順）は高いスコアを上位とし、ポイントベースやハイスコアランキングに適しています。"asc": 昇順 / "desc": 降順 / |
| scope | 文字列列挙型
enum {
"global",
"scoped"
}
| | ✓| | | ランキングの種類
このカテゴリーのランキングタイプ。
"global" は全プレイヤーが共有する単一のリーダーボードを作成し、設定された間隔でバッチ集計されます。
"scoped" は購読したプレイヤー（フレンドやギルドメンバー等）に基づくユーザーごとのリーダーボードを作成し、スコアがリアルタイムで反映されます。"global": グローバル / "scoped": スコープ / |
| globalRankingSetting | [GlobalRankingSetting](#globalrankingsetting) | {scope} == "global" | ✓※| | | グローバルランキング設定
グローバルランキングモード固有の設定。集計間隔、固定時刻、スコアのユニーク性、世代管理、および追加の期間限定スコープを含みます。
scope が "global" に設定されている場合のみ適用されます。
※ scope が "global" であれば必須 |
| entryPeriodEventId | string | | | | ~ 1024文字 | スコア登録期間イベントID
スコア登録を受け付ける期間を定義する GS2-Schedule イベントの GRN。
この期間外のスコア登録リクエストは拒否されます。未設定の場合、スコアはいつでも登録できます。 |
| accessPeriodEventId | string | | | | ~ 1024文字 | アクセス期間イベントID
ランキングデータを閲覧できる期間を定義する GS2-Schedule イベントの GRN。
この期間外のランキング取得リクエストは拒否されます。未設定の場合、ランキングはいつでもアクセスできます。 |
| sum | bool | | | false | | 合算モード
有効にすると、新しく登録されたスコアは既存のスコアを置き換えるのではなく、合計に加算されます。
ランキングは蓄積された合計値に基づいて計算されます。無効の場合、各スコア登録は独立したエントリとして扱われます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | 更新したカテゴリモデルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.UpdateCategoryModelMaster(
&ranking.UpdateCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("CATEGORY_0001"),
MinimumValue: pointy.Int64(100),
MaximumValue: pointy.Int64(10000),
OrderDirection: pointy.String("desc"),
Scope: pointy.String("global"),
GlobalRankingSetting: &ranking.GlobalRankingSetting{
CalculateIntervalMinutes: pointy.Int32(15),
UniqueByUserId: pointy.Bool(true),
AdditionalScopes: []ranking.Scope{
ranking.Scope{
Name: pointy.String("weekly"),
TargetDays: pointy.Int64(7),
},
ranking.Scope{
Name: pointy.String("monthly"),
TargetDays: pointy.Int64(30),
},
},
},
EntryPeriodEventId: nil,
AccessPeriodEventId: nil,
Sum: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UpdateCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->updateCategoryModelMaster(
(new UpdateCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withDescription("description1")
->withMetadata("CATEGORY_0001")
->withMinimumValue(100)
->withMaximumValue(10000)
->withOrderDirection("desc")
->withScope("global")
->withGlobalRankingSetting((new \Gs2\Ranking\Model\GlobalRankingSetting())
->withCalculateIntervalMinutes(15)
->withUniqueByUserId(true)
->withAdditionalScopes([
(new \Gs2\Ranking\Model\Scope())
->withName("weekly")
->withTargetDays(7),
(new \Gs2\Ranking\Model\Scope())
->withName("monthly")
->withTargetDays(30),
]))
->withEntryPeriodEventId(null)
->withAccessPeriodEventId(null)
->withSum(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UpdateCategoryModelMasterRequest;
import io.gs2.ranking.result.UpdateCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UpdateCategoryModelMasterResult result = client.updateCategoryModelMaster(
new UpdateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withDescription("description1")
.withMetadata("CATEGORY_0001")
.withMinimumValue(100L)
.withMaximumValue(10000L)
.withOrderDirection("desc")
.withScope("global")
.withGlobalRankingSetting(new io.gs2.ranking.model.GlobalRankingSetting()
.withCalculateIntervalMinutes(15)
.withUniqueByUserId(true)
.withAdditionalScopes(Arrays.asList(
new io.gs2.ranking.model.Scope()
.withName("weekly")
.withTargetDays(7L),
new io.gs2.ranking.model.Scope()
.withName("monthly")
.withTargetDays(30L)
)))
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
.withSum(null)
);
CategoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCategoryModelMaster(
new Gs2.Gs2Ranking.Request.UpdateCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithDescription("description1")
.WithMetadata("CATEGORY_0001")
.WithMinimumValue(100L)
.WithMaximumValue(10000L)
.WithOrderDirection("desc")
.WithScope("global")
.WithGlobalRankingSetting(new Gs2.Gs2Ranking.Model.GlobalRankingSetting()
.WithCalculateIntervalMinutes(15)
.WithUniqueByUserId(true)
.WithAdditionalScopes(new Gs2.Gs2Ranking.Model.Scope[] {
new Gs2.Gs2Ranking.Model.Scope()
.WithName("weekly")
.WithTargetDays(7L),
new Gs2.Gs2Ranking.Model.Scope()
.WithName("monthly")
.WithTargetDays(30L),
}))
.WithEntryPeriodEventId(null)
.WithAccessPeriodEventId(null)
.WithSum(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.updateCategoryModelMaster(
new Gs2Ranking.UpdateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withDescription("description1")
.withMetadata("CATEGORY_0001")
.withMinimumValue(100)
.withMaximumValue(10000)
.withOrderDirection("desc")
.withScope("global")
.withGlobalRankingSetting(new Gs2Ranking.model.GlobalRankingSetting()
.withCalculateIntervalMinutes(15)
.withUniqueByUserId(true)
.withAdditionalScopes([
new Gs2Ranking.model.Scope()
.withName("weekly")
.withTargetDays(7),
new Gs2Ranking.model.Scope()
.withName("monthly")
.withTargetDays(30),
]))
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
.withSum(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.update_category_model_master(
ranking.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_global_ranking_setting(
ranking.GlobalRankingSetting()
.with_calculate_interval_minutes(15)
.with_unique_by_user_id(True)
.with_additional_scopes([
ranking.Scope()
.with_name('weekly')
.with_target_days(7),
ranking.Scope()
.with_name('monthly')
.with_target_days(30),
]))
.with_entry_period_event_id(None)
.with_access_period_event_id(None)
.with_sum(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.update_category_model_master({
namespaceName="namespace-0001",
categoryName="category-0001",
description="description1",
metadata="CATEGORY_0001",
minimumValue=100,
maximumValue=10000,
orderDirection="desc",
scope="global",
globalRankingSetting={
calculateIntervalMinutes=15,
uniqueByUserId=true,
additionalScopes={
{
name="weekly",
targetDays=7,
},
{
name="monthly",
targetDays=30,
}
},
},
entryPeriodEventId=nil,
accessPeriodEventId=nil,
sum=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.update_category_model_master_async({
namespaceName="namespace-0001",
categoryName="category-0001",
description="description1",
metadata="CATEGORY_0001",
minimumValue=100,
maximumValue=10000,
orderDirection="desc",
scope="global",
globalRankingSetting={
calculateIntervalMinutes=15,
uniqueByUserId=true,
additionalScopes={
{
name="weekly",
targetDays=7,
},
{
name="monthly",
targetDays=30,
}
},
},
entryPeriodEventId=nil,
accessPeriodEventId=nil,
sum=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteCategoryModelMaster
カテゴリモデルマスターを削除
指定されたカテゴリモデルマスターを削除します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| categoryName | string | | ✓| | ~ 128文字 | カテゴリーモデル名
カテゴリーモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | 削除したカテゴリモデルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DeleteCategoryModelMaster(
&ranking.DeleteCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DeleteCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->deleteCategoryModelMaster(
(new DeleteCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DeleteCategoryModelMasterRequest;
import io.gs2.ranking.result.DeleteCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DeleteCategoryModelMasterResult result = client.deleteCategoryModelMaster(
new DeleteCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
CategoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteCategoryModelMaster(
new Gs2.Gs2Ranking.Request.DeleteCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.deleteCategoryModelMaster(
new Gs2Ranking.DeleteCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.delete_category_model_master(
ranking.DeleteCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.delete_category_model_master({
namespaceName="namespace-0001",
categoryName="category-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.delete_category_model_master_async({
namespaceName="namespace-0001",
categoryName="category-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---