> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Lottery SDK API リファレンス
各種プログラミング言語向け GS2-Lottery SDK の モデルの仕様 と API のリファレンス
## モデル
### Namespace
ネームスペース
ネームスペースは、一つのプロジェクト内で同じサービスを異なる用途で複数利用するためのエンティティです。
GS2 の各サービスはネームスペース単位で管理されます。ネームスペースが異なれば、同じサービスでも完全に独立したデータ空間として扱われます。
そのため、各サービスの利用を開始するにあたってネームスペースを作成する必要があります。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024文字 | ネームスペースGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | ✓ | | | トランザクション設定
抽選操作時のトランザクションの処理方法を制御する設定です。抽選では入手アクションを通じてユーザーに景品を付与するトランザクションが発行されます。 |
| lotteryTriggerScriptId | string | | | | ~ 1024文字 | 抽選を実行した際に呼び出される GS2-Script のスクリプトGRN
Script トリガーリファレンス - [`lottery`](../script/#lottery) |
| logSetting | [LogSetting](#logsetting) | | | | | ログの出力設定
抽選操作のAPIリクエスト・レスポンスログを出力するための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" であれば 必須 |
**関連するメソッド:**
updateCurrentLotteryMasterFromGitHub - 現在アクティブな抽選モデルのマスターデータをGitHubから更新
---
### PrizeTable
排出確率テーブル
景品には、入手アクションを指定するか、別の排出確率テーブルを参照させることもできます。
排出確率テーブルを入れ子にすることで、たとえば 1段目で SSR / SR / R などのレアリティを抽選し、2段目でそのレアリティに対応した具体的なコンテンツを抽選するといった設定が可能です。
この仕組みにより、ゲーム全体としてのレアリティ別排出確率を調整しやすくなります。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeTableId | string | | ※ | | ~ 1024文字 | 排出確率テーブルGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | 排出確率テーブル名
排出確率テーブル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 128文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| prizes | [List<Prize>](#prize) | | ✓ | | 1 ~ 100 items | 景品リスト
この排出確率テーブル内の景品リストです。各景品は排出重み（確率）、排出時に実行するアクション、およびオプションの排出回数制限を定義します。各景品の実際の排出確率は、その重みをテーブル内の全景品の重みの合計で割って算出されます。 |
**関連するメソッド:**
describePrizeTables - 排出確率テーブルの一覧を取得
getPrizeTable - 排出確率テーブルを取得
---
### Probability
排出確率
特定の景品の算出された排出確率を表します。確率は排出確率テーブル内の全景品の重みの合計に対するこの景品の重みから計算されます。ボックスガチャの場合、景品がボックスから排出されるにつれて確率は動的に変化します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| prize | [DrawnPrize](#drawnprize) | | ✓ | | | 景品
この確率が対応する景品で、IDと入手アクションを含みます。 |
| rate | float | | ✓ | | 0 ~ 1.0 | 排出確率 (0.0〜1.0)
この景品が排出される確率で、0.0から1.0の値で表されます。この景品の重みをテーブル内の全景品の重みの合計で割って算出されます。 |
**関連するメソッド:**
describeProbabilities - 排出確率の一覧を取得
describeProbabilitiesByUserId - ユーザーIDを指定して排出確率の一覧を取得
---
### PrizeLimit
排出回数制限
特定の景品が全ユーザーを通じて排出された回数を追跡します。排出回数がPrizeのdrawnLimitで定義された最大値に達すると、代わりにフェイルオーバー景品が排出されます。レアなジャックポットアイテムなどの数量限定景品の実装に使用されます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeLimitId | string | | ※ | | ~ 1024文字 | 排出回数制限GRN
※ サーバーが自動で設定 |
| prizeId | string | | ✓ | | ~ 36文字 | 景品ID
排出回数が追跡されている景品のIDです。 |
| drawnCount | int | | ✓ | | 0 ~ 2147483646 | 排出回数
この景品が全ユーザーを通じて排出された現在の回数です。フェイルオーバー景品を使用すべきかどうかを判断するために、PrizeのdrawnLimitと比較されます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describePrizeLimits - 排出回数制限の一覧を取得
getPrizeLimit - 排出回数制限を取得
---
### DrawnPrize
排出された景品
抽選で排出された景品を表します。景品IDとユーザーに景品を付与するために実行された入手アクションを含みます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeId | string | | ✓ | | ~ 36文字 | 景品ID
排出された景品のIDで、排出確率テーブル内の景品エントリに対応します。 |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | | 0 ~ 100 items | 入手アクションのリスト
この景品をユーザーに付与するために実行された入手アクションのリストです。 |
**関連するモデル:**
Probability - 排出確率
---
### BoxItems
ボックスアイテムリスト
特定のユーザーと排出確率テーブルに対するボックスガチャの状態を記録します。ボックス内のすべての景品とその残数・初期数量のリストを含み、どの景品が排出済みでどの景品が残っているかをユーザーが確認できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| boxId | string | | ※ | | ~ 1024文字 | ボックスGRN
※ サーバーが自動で設定 |
| prizeTableName | string | | ✓ | | ~ 128文字 | 排出確率テーブル名
このボックスに関連付けられた排出確率テーブルの名前です。このレコードがどのボックスガチャに属するかを識別します。 |
| userId | string | | ✓ | | ~ 128文字 | ユーザーID |
| items | [List<BoxItem>](#boxitem) | | | [] | 0 ~ 1000 items | アイテムリスト
ボックス内のすべての景品とその残数・初期数量のリストです。各アイテムはその景品が最初にボックスに何個あったか、何個残っているかを示し、ボックスガチャの抽選進行状況の追跡を可能にします。 |
**関連するメソッド:**
describeBoxes - ボックスから取り出したアイテムリストの一覧を取得
describeBoxesByUserId - ユーザーIDを指定してボックスの一覧を取得
getBox - ボックス状態を取得
getBoxByUserId - ユーザーIDを指定してボックス状態を取得
resetBox - ボックスをリセット
resetBoxByUserId - ユーザーIDを指定してボックスをリセット
---
### LotteryModel
抽選モデル
抽選モデルは排出方式や排出テーブルの参照方法を定義するエンティティです。
排出方式は2種類用意されており、通常抽選は毎回一定の確率で抽選をする方式、Box抽選は箱の中にあらかじめ定義された数量の景品が入っており、抽選するたびに箱から景品を取り出していく抽選方式です。
抽選処理を行うにあたって、排出確率テーブルを利用しますが、
GS2-Script を使用すれば複数回抽選を実行した際に排出確率テーブルを一部だけ異なるテーブルに差し替えることができます。
この仕組みを利用することで、10連ガチャで1回だけ異なる抽選確率テーブルを適用することが可能となります。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| lotteryModelId | string | | ※ | | ~ 1024文字 | 抽選モデルGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | 抽選モデル名
抽選モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| mode | 文字列列挙型
enum {
"normal",
"box"
}
| | ✓ | | | 抽選モード
景品の抽選方式を選択します。"normal" は毎回一定の確率で抽選を行います（景品は繰り返し排出されます）。"box" は仮想的な箱にあらかじめ定義された数量の景品を入れ、抽選するたびに箱から景品を取り出します（すべての景品が最終的に排出されることが保証されます）。"normal": 通常抽選 / "box": ボックス抽選 / |
| method | 文字列列挙型
enum {
"prize_table",
"script"
}
| | ✓ | | | 抽選方法
排出確率テーブルの参照方法を決定します。"prize_table" は静的に指定された排出確率テーブルを使用します。"script" はGS2-Scriptを使用して抽選時に動的に排出確率テーブルを選択し、10連ガチャで1回だけ異なる排出確率テーブルを適用するなどのシナリオを実現できます。"prize_table": 静的な排出確率テーブル / "script": GS2-Script による動的な排出確率テーブル / |
| prizeTableName | string | {method} == "prize_table" | ✓※ | | ~ 128文字 | 排出確率テーブルの名前
この抽選モデルで使用する排出確率テーブルの名前です。抽選方法が "prize_table" の場合に必須です。
※ method が "prize_table" であれば 必須 |
| choicePrizeTableScriptId | string | {method} == "script" | ✓※ | | ~ 1024文字 | 排出確率テーブルを決定する GS2-Script のスクリプトGRN
Script トリガーリファレンス - [`choicePrizeTable`](../script/#choiceprizetable)
※ method が "script" であれば 必須 |
**関連するメソッド:**
describeLotteryModels - 抽選モデルの一覧を取得
getLotteryModel - 抽選モデルを取得
---
### Prize
景品
排出確率テーブル内の単一の景品エントリです。
景品は入手アクション（アイテムや通貨の付与など）を直接指定するか、別の排出確率テーブルを参照してネストされた抽選を行えます。
各景品には排出重みがあり、排出される相対的な確率を決定します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeId | string | | ✓ | UUID | ~ 36文字 | 景品ID
排出確率テーブル内でこの景品を一意に識別するIDです。排出回数制限の追跡や、フェイルオーバー景品の指定時の参照に使用されます。 |
| type | 文字列列挙型
enum {
"action",
"prize_table"
}
| | ✓ | | | 景品の種類
この景品が直接報酬を付与するか、別の排出確率テーブルに委譲するかを決定します。"action" は排出時に実行する入手アクションを指定します。"prize_table" は別の排出確率テーブルを参照してネストされた抽選を行います（例：1段目でレアリティを決定、2段目で具体的なアイテムを決定）。"action": 景品の入手アクション / "prize_table": 更に排出確率テーブルを指定して再抽選 / |
| acquireActions | [List<AcquireAction>](#acquireaction) | {type} == "action" | | [] | 1 ~ 100 items | 入手アクションリスト
この景品が排出された時に実行する入手アクションのリストです。複数のアクションを指定して、一度に複数の報酬を付与できます（例：アイテムと通貨を同時に付与）。
※ type が "action" であれば 有効 |
| drawnLimit | int | {type} == "action" | | | 1 ~ 1000000 | 最大排出数
この景品が全ユーザーを通じて排出される最大回数です。制限に達すると、代わりにフェイルオーバー景品（limitFailOverPrizeId）が排出されます。ジャックポットアイテムなどの数量限定景品の実装に使用されます。
※ type が "action" であれば 有効 |
| limitFailOverPrizeId | string | {type} == "action" and {drawnLimit} > 0 | ✓※ | | ~ 32文字 | 制限時フェイルオーバー景品ID
この景品の排出回数制限（drawnLimit）に達した場合に代わりに排出する景品のIDです。同じ排出確率テーブル内の別の景品を参照する必要があります。
※ type が "action" で かつ drawnLimit が 0 より大きければ 必須 |
| prizeTableName | string | {type} == "prize_table" | ✓※ | | ~ 128文字 | 排出確率テーブルの名前
抽選を委譲する排出確率テーブルの名前です。景品タイプが "prize_table" の場合にネストされた抽選に使用されます。
※ type が "prize_table" であれば 必須 |
| weight | int | | ✓ | | 1 ~ 2147483646 | 排出重み
排出確率テーブル内でのこの景品の相対的な重みです。実際の排出確率は、この景品の重みをテーブル内の全景品の重みの合計で割って算出されます。例えば3つの景品の重みが70、20、10の場合、それぞれの排出確率は70%、20%、10%になります。 |
**関連するモデル:**
PrizeTable - 排出確率テーブル
PrizeTableMaster - 排出確率テーブルマスター
---
### BoxItem
ボックスアイテム
ボックスガチャ内の単一の景品タイプを表し、ボックス内の初期数量、残数量、および排出時に実行される入手アクションを示します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeId | string | | ✓ | | ~ 128文字 | 景品ID
このボックスアイテムが対応する排出確率テーブル内の景品IDです。 |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | [] | 0 ~ 100 items | 入手アクションのリスト
この景品がボックスから排出された時に実行する入手アクションのリストです。 |
| remaining | int | | ✓ | | 0 ~ 2147483646 | 残り数量
ボックス内に残っているこの景品の数です。この景品が排出されるたびに1つ減少します。 |
| initial | int | | ✓ | | 0 ~ 2147483646 | 初期数量
最初にボックスに入れられたこの景品の数です。残数と合わせてどれだけ排出されたかを計算するために使用されます。 |
**関連するモデル:**
BoxItems - ボックスアイテムリスト
---
### AcquireAction
入手アクション
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 入手アクションで実行するアクションの種類 |
| request | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
**関連するモデル:**
DrawnPrize - 排出された景品
Prize - 景品
BoxItem - ボックスアイテム
---
### Config
コンフィグ設定
トランザクションの変数に適用する設定値
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| key | string | | ✓ | | ~ 64文字 | 名前 |
| value | string | | | | ~ 51200文字 | 値 |
---
### VerifyActionResult
検証アクションの実行結果
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 検証アクションで実行するアクションの種類 |
| verifyRequest | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
| statusCode | int | | | | 0 ~ 999 | ステータスコード |
| verifyResult | string | | | | ~ 1048576文字 | 結果内容 |
**関連するモデル:**
TransactionResult - トランザクション実行結果
---
### ConsumeActionResult
消費アクションの実行結果
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 消費アクションで実行するアクションの種類 |
| consumeRequest | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
| statusCode | int | | | | 0 ~ 999 | ステータスコード |
| consumeResult | string | | | | ~ 1048576文字 | 結果内容 |
**関連するモデル:**
TransactionResult - トランザクション実行結果
---
### AcquireActionResult
入手アクションの実行結果
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 入手アクションで実行するアクションの種類 |
| acquireRequest | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
| statusCode | int | | | | 0 ~ 999 | ステータスコード |
| acquireResult | string | | | | ~ 1048576文字 | 結果内容 |
**関連するモデル:**
TransactionResult - トランザクション実行結果
---
### TransactionResult
トランザクション実行結果
サーバーサイドでのトランザクションの自動実行機能を利用して実行されたトランザクションの実行結果
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| transactionId | string | | ✓ | | 36 ~ 36文字 | トランザクションID |
| verifyResults | [List<VerifyActionResult>](#verifyactionresult) | | | | 0 ~ 10 items | 検証アクションの実行結果リスト |
| consumeResults | [List<ConsumeActionResult>](#consumeactionresult) | | | [] | 0 ~ 10 items | 消費アクションの実行結果リスト |
| acquireResults | [List<AcquireActionResult>](#acquireactionresult) | | | [] | 0 ~ 100 items | 入手アクションの実行結果リスト |
| hasError | bool | | | false | | トランザクション実行中にエラーが発生したかどうか |
---
### CurrentLotteryMaster
現在アクティブな抽選モデルのマスターデータ
現在ネームスペース内で有効な、抽選モデルの定義を記述したマスターデータです。
GS2ではマスターデータの管理にJSON形式のファイルを使用します。
ファイルをアップロードすることで、実際にサーバーに設定を反映することができます。
JSONファイルを作成する方法として、マネージメントコンソール内にマスターデータエディタを提供しています。
また、よりゲームの運営に相応しいツールを作成し、適切なフォーマットのJSONファイルを書き出すことでもサービスを利用可能です。
{{% alert title="Note" color="info" %}}
JSONファイルの形式については [GS2-Lottery マスターデータリファレンス](api_reference/lottery/master_data/) をご参照ください。
{{% /alert %}}
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024文字 | ネームスペースGRN
※ サーバーが自動で設定 |
| settings | string | | ✓ | | ~ 5242880 バイト (5MB) | マスターデータ |
**関連するメソッド:**
exportMaster - 抽選モデルマスターを有効化可能なマスターデータ形式でエクスポート
getCurrentLotteryMaster - 現在アクティブな抽選モデルのマスターデータを取得
updateCurrentLotteryMaster - 現在アクティブな抽選モデルのマスターデータを更新
updateCurrentLotteryMasterFromGitHub - 現在アクティブな抽選モデルのマスターデータをGitHubから更新
---
### LotteryModelMaster
抽選モデルマスター
抽選モデルマスターは、ゲーム内で使用される抽選モデルの編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。
インポート・更新処理を行うことで、実際にゲームから参照される抽選モデルとして反映されます。
抽選モデルは排出方式や排出テーブルの参照方法を定義するエンティティです。
排出方式は2種類用意されており、通常抽選は毎回一定の確率で抽選をする方式、Box抽選は箱の中にあらかじめ定義された数量の景品が入っており、抽選するたびに箱から景品を取り出していく抽選方式です。
抽選処理を行うにあたって、排出確率テーブルを利用しますが、
GS2-Script を使用すれば複数回抽選を実行した際に排出確率テーブルを一部だけ異なるテーブルに差し替えることができます。
この仕組みを利用することで、10連ガチャで1回だけ異なる抽選確率テーブルを適用することが可能となります。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| lotteryModelId | string | | ※ | | ~ 1024文字 | 抽選モデルマスターGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | 抽選モデル名
抽選モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| mode | 文字列列挙型
enum {
"normal",
"box"
}
| | ✓ | | | 抽選モード
景品の抽選方式を選択します。"normal" は毎回一定の確率で抽選を行います（景品は繰り返し排出されます）。"box" は仮想的な箱にあらかじめ定義された数量の景品を入れ、抽選するたびに箱から景品を取り出します（すべての景品が最終的に排出されることが保証されます）。"normal": 通常抽選 / "box": ボックス抽選 / |
| method | 文字列列挙型
enum {
"prize_table",
"script"
}
| | ✓ | | | 抽選方法
排出確率テーブルの参照方法を決定します。"prize_table" は静的に指定された排出確率テーブルを使用します。
"script" はGS2-Scriptを使用して抽選時に動的に排出確率テーブルを選択し、10連ガチャで1回だけ異なる排出確率テーブルを適用するなどのシナリオを実現できます。"prize_table": 静的な排出確率テーブル / "script": GS2-Script による動的な排出確率テーブル / |
| prizeTableName | string | {method} == "prize_table" | ✓※ | | ~ 128文字 | 排出確率テーブルの名前
この抽選モデルで使用する排出確率テーブルの名前です。抽選方法が "prize_table" の場合に必須です。
※ method が "prize_table" であれば 必須 |
| choicePrizeTableScriptId | string | {method} == "script" | ✓※ | | ~ 1024文字 | 排出確率テーブルを決定する GS2-Script のスクリプトGRN
Script トリガーリファレンス - [`choicePrizeTable`](../script/#choiceprizetable)
※ method が "script" であれば 必須 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeLotteryModelMasters - 抽選モデルマスターの一覧を取得
createLotteryModelMaster - 抽選モデルマスターを新規作成
getLotteryModelMaster - 抽選モデルマスターを取得
updateLotteryModelMaster - 抽選モデルマスターを更新
deleteLotteryModelMaster - 抽選モデルマスターを削除
---
### PrizeTableMaster
排出確率テーブルマスター
排出確率テーブルマスターは、ゲーム内で使用される排出確率テーブルの編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。
インポート・更新処理を行うことで、実際にゲームから参照される排出確率テーブルとして反映されます。
景品には、入手アクションを指定するか、別の排出確率テーブルを参照させることもできます。
排出確率テーブルを入れ子にすることで、たとえば 1段目で SSR / SR / R などのレアリティを抽選し、2段目でそのレアリティに対応した具体的なコンテンツを抽選するといった設定が可能です。
この仕組みにより、ゲーム全体としてのレアリティ別排出確率を調整しやすくなります。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeTableId | string | | ※ | | ~ 1024文字 | 排出確率テーブルマスターGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | 排出確率テーブル名
排出確率テーブル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 128文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| prizes | [List<Prize>](#prize) | | ✓ | | 1 ~ 100 items | 景品リスト
この排出確率テーブル内の景品リストです。各景品は排出重み（確率）、排出時に実行するアクション、およびオプションの排出回数制限を定義します。各景品の実際の排出確率は、その重みをテーブル内の全景品の重みの合計で割って算出されます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describePrizeTableMasters - 排出確率テーブルマスターの一覧を取得
createPrizeTableMaster - 排出確率テーブルマスターを新規作成
getPrizeTableMaster - 排出確率テーブルマスターを取得
updatePrizeTableMaster - 排出確率テーブルマスターを更新
deletePrizeTableMaster - 排出確率テーブルマスターを削除
---
## メソッド
### 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeNamespacesRequest;
import io.gs2.lottery.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_namespaces(
lottery.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('lottery')
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('lottery')
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) | | ✓| | | トランザクション設定
抽選操作時のトランザクションの処理方法を制御する設定です。抽選では入手アクションを通じてユーザーに景品を付与するトランザクションが発行されます。 |
| lotteryTriggerScriptId | string | | | | ~ 1024文字 | 抽選を実行した際に呼び出される GS2-Script のスクリプトGRN
Script トリガーリファレンス - [`lottery`](../script/#lottery) |
| logSetting | [LogSetting](#logsetting) | | | | | ログの出力設定
抽選操作のAPIリクエスト・レスポンスログを出力するためのGS2-Logネームスペースを指定します。デバッグや分析のために抽選結果、景品配布、ボックスガチャの状態追跡に便利です。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 作成したネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&lottery.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
TransactionSetting: &lottery.TransactionSetting{
EnableAutoRun: pointy.Bool(false),
QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"),
},
LotteryTriggerScriptId: nil,
LogSetting: &lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting((new \Gs2\Lottery\Model\TransactionSetting())
->withEnableAutoRun(false)
->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
->withLotteryTriggerScriptId(null)
->withLogSetting((new \Gs2\Lottery\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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CreateNamespaceRequest;
import io.gs2.lottery.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(new io.gs2.lottery.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.withLotteryTriggerScriptId(null)
.withLogSetting(new io.gs2.lottery.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2Lottery.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(new Gs2.Gs2Lottery.Model.TransactionSetting()
.WithEnableAutoRun(false)
.WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.WithLotteryTriggerScriptId(null)
.WithLogSetting(new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.createNamespace(
new Gs2Lottery.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(new Gs2Lottery.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.withLotteryTriggerScriptId(null)
.withLogSetting(new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.create_namespace(
lottery.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_transaction_setting(
lottery.TransactionSetting()
.with_enable_auto_run(False)
.with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001'))
.with_lottery_trigger_script_id(None)
.with_log_setting(
lottery.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('lottery')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
},
lotteryTriggerScriptId=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('lottery')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
},
lotteryTriggerScriptId=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 | |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetNamespaceStatusRequest;
import io.gs2.lottery.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2Lottery.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_namespace_status(
lottery.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetNamespaceRequest;
import io.gs2.lottery.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getNamespace(
new Gs2Lottery.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_namespace(
lottery.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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) | | ✓| | | トランザクション設定
抽選操作時のトランザクションの処理方法を制御する設定です。抽選では入手アクションを通じてユーザーに景品を付与するトランザクションが発行されます。 |
| lotteryTriggerScriptId | string | | | | ~ 1024文字 | 抽選を実行した際に呼び出される GS2-Script のスクリプトGRN
Script トリガーリファレンス - [`lottery`](../script/#lottery) |
| logSetting | [LogSetting](#logsetting) | | | | | ログの出力設定
抽選操作のAPIリクエスト・レスポンスログを出力するためのGS2-Logネームスペースを指定します。デバッグや分析のために抽選結果、景品配布、ボックスガチャの状態追跡に便利です。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 更新したネームスペース |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&lottery.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
TransactionSetting: &lottery.TransactionSetting{
EnableAutoRun: pointy.Bool(false),
QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"),
},
LotteryTriggerScriptId: nil,
LogSetting: &lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting((new \Gs2\Lottery\Model\TransactionSetting())
->withEnableAutoRun(false)
->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
->withLotteryTriggerScriptId(null)
->withLogSetting((new \Gs2\Lottery\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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.UpdateNamespaceRequest;
import io.gs2.lottery.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(new io.gs2.lottery.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.withLotteryTriggerScriptId(null)
.withLogSetting(new io.gs2.lottery.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2Lottery.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(new Gs2.Gs2Lottery.Model.TransactionSetting()
.WithEnableAutoRun(false)
.WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.WithLotteryTriggerScriptId(null)
.WithLogSetting(new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2Lottery.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(new Gs2Lottery.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.withLotteryTriggerScriptId(null)
.withLogSetting(new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.update_namespace(
lottery.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_transaction_setting(
lottery.TransactionSetting()
.with_enable_auto_run(False)
.with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002'))
.with_lottery_trigger_script_id(None)
.with_log_setting(
lottery.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('lottery')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
},
lotteryTriggerScriptId=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('lottery')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
},
lotteryTriggerScriptId=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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DeleteNamespaceRequest;
import io.gs2.lottery.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2Lottery.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.delete_namespace(
lottery.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetServiceVersionRequest;
import io.gs2.lottery.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2Lottery.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_service_version(
lottery.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DumpUserDataByUserIdRequest;
import io.gs2.lottery.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2Lottery.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.dump_user_data_by_user_id(
lottery.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.lottery.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2Lottery.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
lottery.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('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CleanUserDataByUserIdRequest;
import io.gs2.lottery.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2Lottery.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.clean_user_data_by_user_id(
lottery.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.lottery.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2Lottery.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
lottery.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.lottery.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
lottery.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('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.ImportUserDataByUserIdRequest;
import io.gs2.lottery.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2Lottery.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.import_user_data_by_user_id(
lottery.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('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CheckImportUserDataByUserIdRequest;
import io.gs2.lottery.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.check_import_user_data_by_user_id(
lottery.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('lottery')
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('lottery')
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;
```
---
### describePrizeTables
排出確率テーブルの一覧を取得
指定されたネームスペースの現在アクティブな排出確率テーブルの一覧を取得します。
排出確率テーブルは、抽選モデルが使用する景品とその排出確率または重みを定義します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<PrizeTable>](#prizetable) | 排出確率テーブルのリスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribePrizeTables(
&lottery.DescribePrizeTablesRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribePrizeTablesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describePrizeTables(
(new DescribePrizeTablesRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribePrizeTablesRequest;
import io.gs2.lottery.result.DescribePrizeTablesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribePrizeTablesResult result = client.describePrizeTables(
new DescribePrizeTablesRequest()
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribePrizeTables(
new Gs2.Gs2Lottery.Request.DescribePrizeTablesRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describePrizeTables(
new Gs2Lottery.DescribePrizeTablesRequest()
.withNamespaceName("namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_prize_tables(
lottery.DescribePrizeTablesRequest()
.with_namespace_name('namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_prize_tables({
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('lottery')
api_result_handler = client.describe_prize_tables_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;
```
---
### getPrizeTable
排出確率テーブルを取得
指定された排出確率テーブルの景品リスト、排出確率、重み、数量制限を含む情報を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名
排出確率テーブル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [PrizeTable](#prizetable) | 排出確率テーブル |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetPrizeTable(
&lottery.GetPrizeTableRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetPrizeTableRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getPrizeTable(
(new GetPrizeTableRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetPrizeTableRequest;
import io.gs2.lottery.result.GetPrizeTableResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetPrizeTableResult result = client.getPrizeTable(
new GetPrizeTableRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
PrizeTable 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetPrizeTable(
new Gs2.Gs2Lottery.Request.GetPrizeTableRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getPrizeTable(
new Gs2Lottery.GetPrizeTableRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_prize_table(
lottery.GetPrizeTableRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_prize_table({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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('lottery')
api_result_handler = client.get_prize_table_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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;
```
---
### drawByUserId
ユーザーIDを指定して抽選を実行
抽選モデルの設定に基づいて、指定されたユーザーの抽選を実行します。
抽選は2つの方式をサポートします：排出確率テーブルモード（事前定義された確率テーブルを使用）とスクリプトモード（GS2-Script で景品を決定）。
ボックス抽選モードでは、排出された景品はボックスから削除され再度排出されません。ボックスが空の場合は Empty エラーが返されます。
排出された景品はトランザクションとして発行されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名 |
| lotteryName | string | | ✓| | ~ 128文字 | 抽選モデル名
抽選モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| count | int | | ✓| | 1 ~ 1000 | 抽選回数 |
| config | [List<Config>](#config) | | | [] | 0 ~ 1000 items | トランザクションのプレースホルダに適用する設定値 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | 抽選結果の景品リスト |
| boxItems | [BoxItems](#boxitems) | ボックスから取り出したアイテムのリスト |
| transactionId | string | 発行されたトランザクションID |
| stampSheet | string | 排出された景品を入手するスタンプシート |
| stampSheetEncryptionKeyId | string | スタンプシートの署名計算に使用した暗号鍵GRN |
| autoRunStampSheet | bool? | トランザクションの自動実行が有効か |
| atomicCommit | bool? | トランザクションをアトミックにコミットするか |
| transaction | string | 発行されたトランザクション |
| transactionResult | [TransactionResult](#transactionresult) | トランザクション実行結果 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DrawByUserId(
&lottery.DrawByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-0001"),
UserId: pointy.String("user-0001"),
Count: pointy.Int32(1),
Config: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
boxItems := result.BoxItems
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet
atomicCommit := result.AtomicCommit
transaction := result.Transaction
transactionResult := result.TransactionResult
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DrawByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->drawByUserId(
(new DrawByUserIdRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-0001")
->withUserId("user-0001")
->withCount(1)
->withConfig(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$boxItems = $result->getBoxItems();
$transactionId = $result->getTransactionId();
$stampSheet = $result->getStampSheet();
$stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
$autoRunStampSheet = $result->getAutoRunStampSheet();
$atomicCommit = $result->getAtomicCommit();
$transaction = $result->getTransaction();
$transactionResult = $result->getTransactionResult();
} 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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DrawByUserIdRequest;
import io.gs2.lottery.result.DrawByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DrawByUserIdResult result = client.drawByUserId(
new DrawByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withCount(1)
.withConfig(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
BoxItems boxItems = result.getBoxItems();
String transactionId = result.getTransactionId();
String stampSheet = result.getStampSheet();
String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
boolean autoRunStampSheet = result.getAutoRunStampSheet();
boolean atomicCommit = result.getAtomicCommit();
String transaction = result.getTransaction();
TransactionResult transactionResult = result.getTransactionResult();
} 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DrawByUserId(
new Gs2.Gs2Lottery.Request.DrawByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-0001")
.WithUserId("user-0001")
.WithCount(1)
.WithConfig(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var boxItems = result.BoxItems;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.drawByUserId(
new Gs2Lottery.DrawByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withCount(1)
.withConfig(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const boxItems = result.getBoxItems();
const transactionId = result.getTransactionId();
const stampSheet = result.getStampSheet();
const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
const autoRunStampSheet = result.getAutoRunStampSheet();
const atomicCommit = result.getAtomicCommit();
const transaction = result.getTransaction();
const transactionResult = result.getTransactionResult();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.draw_by_user_id(
lottery.DrawByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_user_id('user-0001')
.with_count(1)
.with_config(None)
.with_time_offset_token(None)
)
items = result.items
box_items = result.box_items
transaction_id = result.transaction_id
stamp_sheet = result.stamp_sheet
stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
auto_run_stamp_sheet = result.auto_run_stamp_sheet
atomic_commit = result.atomic_commit
transaction = result.transaction
transaction_result = result.transaction_result
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.draw_by_user_id({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
count=1,
config=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;
boxItems = result.boxItems;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.draw_by_user_id_async({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
count=1,
config=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;
boxItems = result.boxItems;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### prediction
抽選結果の予測結果を取得
実際に景品を付与したりトランザクションを生成せずに、抽選結果を予測します。
乱数シードを使用して決定論的な結果を返すため、同じシードで同じ予測結果を再現できます。
抽選を実行する前に、プレイヤーに受け取る景品を表示する場合に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名 |
| lotteryName | string | | ✓| | ~ 128文字 | 抽選モデル名 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| randomSeed | long | | ✓| | 0 ~ 9223372036854775805 | 乱数シード |
| count | int | | ✓| | 1 ~ 1000 | 抽選回数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | 抽選結果の景品リスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.Prediction(
&lottery.PredictionRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-0001"),
AccessToken: pointy.String("accessToken-0001"),
RandomSeed: pointy.Int64(1),
Count: pointy.Int32(1),
}
)
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\PredictionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->prediction(
(new PredictionRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-0001")
->withAccessToken("accessToken-0001")
->withRandomSeed(1)
->withCount(1)
);
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.PredictionRequest;
import io.gs2.lottery.result.PredictionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
PredictionResult result = client.prediction(
new PredictionRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withAccessToken("accessToken-0001")
.withRandomSeed(1L)
.withCount(1)
);
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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.Prediction(
new Gs2.Gs2Lottery.Request.PredictionRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-0001")
.WithAccessToken("accessToken-0001")
.WithRandomSeed(1L)
.WithCount(1),
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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.prediction(
new Gs2Lottery.PredictionRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withAccessToken("accessToken-0001")
.withRandomSeed(1)
.withCount(1)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.prediction(
lottery.PredictionRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_access_token('accessToken-0001')
.with_random_seed(1)
.with_count(1)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.prediction({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
accessToken="accessToken-0001",
randomSeed=1,
count=1,
})
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('lottery')
api_result_handler = client.prediction_async({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
accessToken="accessToken-0001",
randomSeed=1,
count=1,
})
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;
```
---
### predictionByUserId
ユーザーIDを指定して抽選結果の予測結果を取得
指定されたユーザーの抽選結果を、景品の付与やトランザクションの生成なしに予測します。
乱数シードを使用して決定論的な結果を返します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名 |
| lotteryName | string | | ✓| | ~ 128文字 | 抽選モデル名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| randomSeed | long | | ✓| | 0 ~ 9223372036854775805 | 乱数シード |
| count | int | | ✓| | 1 ~ 1000 | 抽選回数 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | 抽選結果の景品リスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.PredictionByUserId(
&lottery.PredictionByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-0001"),
UserId: pointy.String("user-0001"),
RandomSeed: pointy.Int64(1),
Count: pointy.Int32(1),
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\PredictionByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->predictionByUserId(
(new PredictionByUserIdRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-0001")
->withUserId("user-0001")
->withRandomSeed(1)
->withCount(1)
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.PredictionByUserIdRequest;
import io.gs2.lottery.result.PredictionByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
PredictionByUserIdResult result = client.predictionByUserId(
new PredictionByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withRandomSeed(1L)
.withCount(1)
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.PredictionByUserId(
new Gs2.Gs2Lottery.Request.PredictionByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-0001")
.WithUserId("user-0001")
.WithRandomSeed(1L)
.WithCount(1)
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.predictionByUserId(
new Gs2Lottery.PredictionByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withRandomSeed(1)
.withCount(1)
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.prediction_by_user_id(
lottery.PredictionByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_user_id('user-0001')
.with_random_seed(1)
.with_count(1)
.with_time_offset_token(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.prediction_by_user_id({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
randomSeed=1,
count=1,
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('lottery')
api_result_handler = client.prediction_by_user_id_async({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
randomSeed=1,
count=1,
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;
```
---
### drawWithRandomSeedByUserId
ユーザーIDを指定して乱数シード付きで抽選を実行
指定された乱数シードを使用して決定論的な抽選を実行します。
乱数シードは各抽選のイテレーションカウントでオフセットされ、ユニークかつ再現可能な結果を保証します。
この方式はボックス抽選モードとは互換性がありません。排出された景品はトランザクションとして発行されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名 |
| lotteryName | string | | ✓| | ~ 128文字 | 抽選モデル名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| randomSeed | long | | ✓| | 0 ~ 9223372036854775805 | 乱数シード |
| count | int | | ✓| | 1 ~ 1000 | 抽選回数 |
| config | [List<Config>](#config) | | | [] | 0 ~ 1000 items | トランザクションのプレースホルダに適用する設定値 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | 抽選結果の景品リスト |
| transactionId | string | 発行されたトランザクションID |
| stampSheet | string | 排出された景品を入手するスタンプシート |
| stampSheetEncryptionKeyId | string | スタンプシートの署名計算に使用した暗号鍵GRN |
| autoRunStampSheet | bool? | トランザクションの自動実行が有効か |
| atomicCommit | bool? | トランザクションをアトミックにコミットするか |
| transaction | string | 発行されたトランザクション |
| transactionResult | [TransactionResult](#transactionresult) | トランザクション実行結果 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DrawWithRandomSeedByUserId(
&lottery.DrawWithRandomSeedByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-0001"),
UserId: pointy.String("user-0001"),
RandomSeed: pointy.Int64(1),
Count: pointy.Int32(1),
Config: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet
atomicCommit := result.AtomicCommit
transaction := result.Transaction
transactionResult := result.TransactionResult
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DrawWithRandomSeedByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->drawWithRandomSeedByUserId(
(new DrawWithRandomSeedByUserIdRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-0001")
->withUserId("user-0001")
->withRandomSeed(1)
->withCount(1)
->withConfig(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$transactionId = $result->getTransactionId();
$stampSheet = $result->getStampSheet();
$stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
$autoRunStampSheet = $result->getAutoRunStampSheet();
$atomicCommit = $result->getAtomicCommit();
$transaction = $result->getTransaction();
$transactionResult = $result->getTransactionResult();
} 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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DrawWithRandomSeedByUserIdRequest;
import io.gs2.lottery.result.DrawWithRandomSeedByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DrawWithRandomSeedByUserIdResult result = client.drawWithRandomSeedByUserId(
new DrawWithRandomSeedByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withRandomSeed(1L)
.withCount(1)
.withConfig(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
String transactionId = result.getTransactionId();
String stampSheet = result.getStampSheet();
String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
boolean autoRunStampSheet = result.getAutoRunStampSheet();
boolean atomicCommit = result.getAtomicCommit();
String transaction = result.getTransaction();
TransactionResult transactionResult = result.getTransactionResult();
} 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DrawWithRandomSeedByUserId(
new Gs2.Gs2Lottery.Request.DrawWithRandomSeedByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-0001")
.WithUserId("user-0001")
.WithRandomSeed(1L)
.WithCount(1)
.WithConfig(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.drawWithRandomSeedByUserId(
new Gs2Lottery.DrawWithRandomSeedByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withRandomSeed(1)
.withCount(1)
.withConfig(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const transactionId = result.getTransactionId();
const stampSheet = result.getStampSheet();
const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
const autoRunStampSheet = result.getAutoRunStampSheet();
const atomicCommit = result.getAtomicCommit();
const transaction = result.getTransaction();
const transactionResult = result.getTransactionResult();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.draw_with_random_seed_by_user_id(
lottery.DrawWithRandomSeedByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_user_id('user-0001')
.with_random_seed(1)
.with_count(1)
.with_config(None)
.with_time_offset_token(None)
)
items = result.items
transaction_id = result.transaction_id
stamp_sheet = result.stamp_sheet
stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
auto_run_stamp_sheet = result.auto_run_stamp_sheet
atomic_commit = result.atomic_commit
transaction = result.transaction
transaction_result = result.transaction_result
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.draw_with_random_seed_by_user_id({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
randomSeed=1,
count=1,
config=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;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.draw_with_random_seed_by_user_id_async({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
randomSeed=1,
count=1,
config=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;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### describeProbabilities
排出確率の一覧を取得
通常抽選ではすべてのゲームプレイヤーに対して同じ確率を応答します。
ボックス抽選ではボックスの中身の残りを考慮したゲームプレイヤーごとに異なる確率を応答します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| lotteryName | string | | ✓| | ~ 128文字 | 抽選モデル名
抽選モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Probability>](#probability) | 排出確率リスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeProbabilities(
&lottery.DescribeProbabilitiesRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeProbabilitiesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeProbabilities(
(new DescribeProbabilitiesRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeProbabilitiesRequest;
import io.gs2.lottery.result.DescribeProbabilitiesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeProbabilitiesResult result = client.describeProbabilities(
new DescribeProbabilitiesRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeProbabilities(
new Gs2.Gs2Lottery.Request.DescribeProbabilitiesRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeProbabilities(
new Gs2Lottery.DescribeProbabilitiesRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withAccessToken("accessToken-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_probabilities(
lottery.DescribeProbabilitiesRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_access_token('accessToken-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_probabilities({
namespaceName="namespace-0001",
lotteryName="lottery-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('lottery')
api_result_handler = client.describe_probabilities_async({
namespaceName="namespace-0001",
lotteryName="lottery-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;
```
---
### describeProbabilitiesByUserId
ユーザーIDを指定して排出確率の一覧を取得
通常抽選ではすべてのゲームプレイヤーに対して同じ確率を応答します。
ボックス抽選ではボックスの中身の残りを考慮したゲームプレイヤーごとに異なる確率を応答します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| lotteryName | string | | ✓| | ~ 128文字 | 抽選モデル名
抽選モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Probability>](#probability) | 排出確率リスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeProbabilitiesByUserId(
&lottery.DescribeProbabilitiesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeProbabilitiesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeProbabilitiesByUserId(
(new DescribeProbabilitiesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeProbabilitiesByUserIdRequest;
import io.gs2.lottery.result.DescribeProbabilitiesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeProbabilitiesByUserIdResult result = client.describeProbabilitiesByUserId(
new DescribeProbabilitiesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeProbabilitiesByUserId(
new Gs2.Gs2Lottery.Request.DescribeProbabilitiesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeProbabilitiesByUserId(
new Gs2Lottery.DescribeProbabilitiesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_probabilities_by_user_id(
lottery.DescribeProbabilitiesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-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('lottery')
api_result = client.describe_probabilities_by_user_id({
namespaceName="namespace-0001",
lotteryName="lottery-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('lottery')
api_result_handler = client.describe_probabilities_by_user_id_async({
namespaceName="namespace-0001",
lotteryName="lottery-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;
```
---
### describePrizeLimits
排出回数制限の一覧を取得
指定された排出確率テーブルの景品排出回数制限のページネーション付きリストを取得します。
排出回数制限は各景品の排出回数を追跡し、数量限定の景品設定を可能にします。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名
排出確率テーブル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<PrizeLimit>](#prizelimit) | 排出回数制限のリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribePrizeLimits(
&lottery.DescribePrizeLimitsRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribePrizeLimitsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describePrizeLimits(
(new DescribePrizeLimitsRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribePrizeLimitsRequest;
import io.gs2.lottery.result.DescribePrizeLimitsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribePrizeLimitsResult result = client.describePrizeLimits(
new DescribePrizeLimitsRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribePrizeLimits(
new Gs2.Gs2Lottery.Request.DescribePrizeLimitsRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describePrizeLimits(
new Gs2Lottery.DescribePrizeLimitsRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_prize_limits(
lottery.DescribePrizeLimitsRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_prize_limits({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
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('lottery')
api_result_handler = client.describe_prize_limits_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### getPrizeLimit
排出回数制限を取得
排出確率テーブル内の特定の景品の現在の排出回数制限を取得します。
設定された制限に対して景品が何回排出されたかを確認できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名
排出確率テーブル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeId | string | | ✓| UUID | ~ 36文字 | 景品ID
排出確率テーブル内でこの景品を一意に識別するIDです。排出回数制限の追跡や、フェイルオーバー景品の指定時の参照に使用されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [PrizeLimit](#prizelimit) | 排出回数制限 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetPrizeLimit(
&lottery.GetPrizeLimitRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
PrizeId: pointy.String("prize-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetPrizeLimitRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getPrizeLimit(
(new GetPrizeLimitRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withPrizeId("prize-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetPrizeLimitRequest;
import io.gs2.lottery.result.GetPrizeLimitResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetPrizeLimitResult result = client.getPrizeLimit(
new GetPrizeLimitRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withPrizeId("prize-0001")
);
PrizeLimit 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetPrizeLimit(
new Gs2.Gs2Lottery.Request.GetPrizeLimitRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithPrizeId("prize-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getPrizeLimit(
new Gs2Lottery.GetPrizeLimitRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withPrizeId("prize-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_prize_limit(
lottery.GetPrizeLimitRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_prize_id('prize-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_prize_limit({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
prizeId="prize-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('lottery')
api_result_handler = client.get_prize_limit_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
prizeId="prize-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;
```
---
### resetPrizeLimit
排出回数をリセット
排出回数レコードを削除して、特定の景品の排出回数をリセットします。
リセット後、景品は設定された制限まで再度排出可能になります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名
排出確率テーブル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeId | string | | ✓| UUID | ~ 36文字 | 景品ID
排出確率テーブル内でこの景品を一意に識別するIDです。排出回数制限の追跡や、フェイルオーバー景品の指定時の参照に使用されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.ResetPrizeLimit(
&lottery.ResetPrizeLimitRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
PrizeId: pointy.String("prize-0001"),
}
)
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\ResetPrizeLimitRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->resetPrizeLimit(
(new ResetPrizeLimitRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withPrizeId("prize-0001")
);
} 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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.ResetPrizeLimitRequest;
import io.gs2.lottery.result.ResetPrizeLimitResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
ResetPrizeLimitResult result = client.resetPrizeLimit(
new ResetPrizeLimitRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withPrizeId("prize-0001")
);
} 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.ResetPrizeLimit(
new Gs2.Gs2Lottery.Request.ResetPrizeLimitRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithPrizeId("prize-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.resetPrizeLimit(
new Gs2Lottery.ResetPrizeLimitRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withPrizeId("prize-0001")
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.reset_prize_limit(
lottery.ResetPrizeLimitRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_prize_id('prize-0001')
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.reset_prize_limit({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
prizeId="prize-0001",
})
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('lottery')
api_result_handler = client.reset_prize_limit_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
prizeId="prize-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
```
---
### describeBoxes
ボックスから取り出したアイテムリストの一覧を取得
ネームスペース内のすべてのボックスモード抽選モデルのボックス状態をページネーション付きで取得します。
各エントリは、ボックスからどの景品が排出されたか、残りの数量を示します。
まだ抽選が行われていないボックスの場合、空のボックス状態が作成されて返されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<BoxItems>](#boxitems) | ボックス状態のリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeBoxes(
&lottery.DescribeBoxesRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeBoxesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeBoxes(
(new DescribeBoxesRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeBoxesRequest;
import io.gs2.lottery.result.DescribeBoxesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeBoxesResult result = client.describeBoxes(
new DescribeBoxesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeBoxes(
new Gs2.Gs2Lottery.Request.DescribeBoxesRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeBoxes(
new Gs2Lottery.DescribeBoxesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_boxes(
lottery.DescribeBoxesRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_boxes({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
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('lottery')
api_result_handler = client.describe_boxes_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeBoxesByUserId
ユーザーIDを指定してボックスの一覧を取得
指定されたユーザーのすべてのボックスモード抽選モデルのボックス状態をページネーション付きで取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<BoxItems>](#boxitems) | ボックス状態のリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeBoxesByUserId(
&lottery.DescribeBoxesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeBoxesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeBoxesByUserId(
(new DescribeBoxesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeBoxesByUserIdRequest;
import io.gs2.lottery.result.DescribeBoxesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeBoxesByUserIdResult result = client.describeBoxesByUserId(
new DescribeBoxesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeBoxesByUserId(
new Gs2.Gs2Lottery.Request.DescribeBoxesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeBoxesByUserId(
new Gs2Lottery.DescribeBoxesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_boxes_by_user_id(
lottery.DescribeBoxesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.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('lottery')
api_result = client.describe_boxes_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
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('lottery')
api_result_handler = client.describe_boxes_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
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;
```
---
### getBox
ボックス状態を取得
特定の排出確率テーブルのボックス状態を取得し、どの景品が排出済みか、残りの数量を表示します。
ボックスがまだ存在しない場合、空のボックス状態が作成されて返されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | ボックス内の景品と残数の情報 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetBox(
&lottery.GetBoxRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
AccessToken: pointy.String("accessToken-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetBoxRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getBox(
(new GetBoxRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withAccessToken("accessToken-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetBoxRequest;
import io.gs2.lottery.result.GetBoxResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetBoxResult result = client.getBox(
new GetBoxRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withAccessToken("accessToken-0001")
);
BoxItems 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetBox(
new Gs2.Gs2Lottery.Request.GetBoxRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithAccessToken("accessToken-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getBox(
new Gs2Lottery.GetBoxRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_box(
lottery.GetBoxRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_box({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
accessToken="accessToken-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('lottery')
api_result_handler = client.get_box_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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
item = result.item;
```
---
### getBoxByUserId
ユーザーIDを指定してボックス状態を取得
指定されたユーザーの特定の排出確率テーブルのボックス状態を取得し、排出済み景品と残りの数量を表示します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | ボックス内の景品と残数の情報 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetBoxByUserId(
&lottery.GetBoxByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
UserId: pointy.String("user-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetBoxByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getBoxByUserId(
(new GetBoxByUserIdRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withUserId("user-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetBoxByUserIdRequest;
import io.gs2.lottery.result.GetBoxByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetBoxByUserIdResult result = client.getBoxByUserId(
new GetBoxByUserIdRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
BoxItems 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetBoxByUserId(
new Gs2.Gs2Lottery.Request.GetBoxByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithUserId("user-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getBoxByUserId(
new Gs2Lottery.GetBoxByUserIdRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_box_by_user_id(
lottery.GetBoxByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_user_id('user-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_box_by_user_id({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.get_box_by_user_id_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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
item = result.item;
```
---
### resetBox
ボックスをリセット
ボックスを初期状態にリセットし、排出済みのすべての景品をボックスに戻します。
リセット後、すべての景品が再度排出可能になります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | ボックス内の景品と初期数量の情報 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.ResetBox(
&lottery.ResetBoxRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
AccessToken: pointy.String("accessToken-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\ResetBoxRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->resetBox(
(new ResetBoxRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withAccessToken("accessToken-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.ResetBoxRequest;
import io.gs2.lottery.result.ResetBoxResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
ResetBoxResult result = client.resetBox(
new ResetBoxRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withAccessToken("accessToken-0001")
);
BoxItems 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.ResetBox(
new Gs2.Gs2Lottery.Request.ResetBoxRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithAccessToken("accessToken-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.resetBox(
new Gs2Lottery.ResetBoxRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.reset_box(
lottery.ResetBoxRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.reset_box({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
accessToken="accessToken-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('lottery')
api_result_handler = client.reset_box_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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
item = result.item;
```
---
### resetBoxByUserId
ユーザーIDを指定してボックスをリセット
指定されたユーザーのボックスを初期状態にリセットし、排出済みのすべての景品をボックスに戻します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | ボックス内の景品と初期数量の情報 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.ResetBoxByUserId(
&lottery.ResetBoxByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
UserId: pointy.String("user-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\ResetBoxByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->resetBoxByUserId(
(new ResetBoxByUserIdRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withUserId("user-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.ResetBoxByUserIdRequest;
import io.gs2.lottery.result.ResetBoxByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
ResetBoxByUserIdResult result = client.resetBoxByUserId(
new ResetBoxByUserIdRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
BoxItems 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.ResetBoxByUserId(
new Gs2.Gs2Lottery.Request.ResetBoxByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithUserId("user-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.resetBoxByUserId(
new Gs2Lottery.ResetBoxByUserIdRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.reset_box_by_user_id(
lottery.ResetBoxByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_user_id('user-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.reset_box_by_user_id({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.reset_box_by_user_id_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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
item = result.item;
```
---
### describeLotteryModels
抽選モデルの一覧を取得
指定されたネームスペースの現在アクティブな抽選モデルの一覧を取得します。
モデルは抽選モード（通常またはボックス）、抽選方式（排出確率テーブルまたはスクリプト）、および関連する排出確率テーブルの設定を定義します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<LotteryModel>](#lotterymodel) | 抽選モデルのリスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeLotteryModels(
&lottery.DescribeLotteryModelsRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeLotteryModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeLotteryModels(
(new DescribeLotteryModelsRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeLotteryModelsRequest;
import io.gs2.lottery.result.DescribeLotteryModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeLotteryModelsResult result = client.describeLotteryModels(
new DescribeLotteryModelsRequest()
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeLotteryModels(
new Gs2.Gs2Lottery.Request.DescribeLotteryModelsRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeLotteryModels(
new Gs2Lottery.DescribeLotteryModelsRequest()
.withNamespaceName("namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_lottery_models(
lottery.DescribeLotteryModelsRequest()
.with_namespace_name('namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_lottery_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('lottery')
api_result_handler = client.describe_lottery_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;
```
---
### getLotteryModel
抽選モデルを取得
指定された抽選モデルのモード（通常/ボックス）、抽選方式（排出確率テーブル/スクリプト）、排出確率テーブル名を含む情報を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| lotteryName | string | | ✓| | ~ 128文字 | 抽選モデル名
抽選モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [LotteryModel](#lotterymodel) | 抽選モデル |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetLotteryModel(
&lottery.GetLotteryModelRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lotteryModel-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetLotteryModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getLotteryModel(
(new GetLotteryModelRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lotteryModel-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetLotteryModelRequest;
import io.gs2.lottery.result.GetLotteryModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetLotteryModelResult result = client.getLotteryModel(
new GetLotteryModelRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
LotteryModel 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetLotteryModel(
new Gs2.Gs2Lottery.Request.GetLotteryModelRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lotteryModel-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getLotteryModel(
new Gs2Lottery.GetLotteryModelRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_lottery_model(
lottery.GetLotteryModelRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lotteryModel-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_lottery_model({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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('lottery')
api_result_handler = client.get_lottery_model_async({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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 | [CurrentLotteryMaster](#currentlotterymaster) | 有効化可能な抽選モデルのマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.ExportMaster(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\ExportMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.ExportMasterRequest;
import io.gs2.lottery.result.ExportMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
ExportMasterResult result = client.exportMaster(
new ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentLotteryMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExportMaster(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.exportMaster(
new Gs2Lottery.ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.export_master(
lottery.ExportMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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;
```
---
### getCurrentLotteryMaster
現在アクティブな抽選モデルのマスターデータを取得
指定されたネームスペースの現在アクティブな抽選モデルのマスターデータを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentLotteryMaster](#currentlotterymaster) | 現在アクティブな抽選モデルのマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetCurrentLotteryMaster(
&lottery.GetCurrentLotteryMasterRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetCurrentLotteryMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getCurrentLotteryMaster(
(new GetCurrentLotteryMasterRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetCurrentLotteryMasterRequest;
import io.gs2.lottery.result.GetCurrentLotteryMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetCurrentLotteryMasterResult result = client.getCurrentLotteryMaster(
new GetCurrentLotteryMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentLotteryMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCurrentLotteryMaster(
new Gs2.Gs2Lottery.Request.GetCurrentLotteryMasterRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getCurrentLotteryMaster(
new Gs2Lottery.GetCurrentLotteryMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_current_lottery_master(
lottery.GetCurrentLotteryMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_current_lottery_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('lottery')
api_result_handler = client.get_current_lottery_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;
```
---
### preUpdateCurrentLotteryMaster
現在アクティブな抽選モデルのマスターデータを更新（3フェーズ版）
1MBを超えるマスターデータをアップロードする場合は、3フェーズで更新を行います。
1. このAPIを実行し、アップロード用のトークンとURLを取得します。
2. 取得したURLに対して、マスターデータをアップロードします。
3. UpdateCurrentLotteryMaster にアップロードで取得したトークンを渡して実行し、マスターデータを反映します。
#### 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.PreUpdateCurrentLotteryMaster(
&lottery.PreUpdateCurrentLotteryMasterRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\PreUpdateCurrentLotteryMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->preUpdateCurrentLotteryMaster(
(new PreUpdateCurrentLotteryMasterRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.PreUpdateCurrentLotteryMasterRequest;
import io.gs2.lottery.result.PreUpdateCurrentLotteryMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
PreUpdateCurrentLotteryMasterResult result = client.preUpdateCurrentLotteryMaster(
new PreUpdateCurrentLotteryMasterRequest()
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.PreUpdateCurrentLotteryMaster(
new Gs2.Gs2Lottery.Request.PreUpdateCurrentLotteryMasterRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.preUpdateCurrentLotteryMaster(
new Gs2Lottery.PreUpdateCurrentLotteryMasterRequest()
.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.pre_update_current_lottery_master(
lottery.PreUpdateCurrentLotteryMasterRequest()
.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('lottery')
api_result = client.pre_update_current_lottery_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('lottery')
api_result_handler = client.pre_update_current_lottery_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;
```
---
### updateCurrentLotteryMaster
現在アクティブな抽選モデルのマスターデータを更新
現在アクティブな抽選モデルのマスターデータを更新します。
2つのモードをサポートします：インライン設定用の 'direct' モードと、3フェーズ更新プロセスで事前にアップロードした設定を適用する 'preUpload' モードです。
#### 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 | [CurrentLotteryMaster](#currentlotterymaster) | 更新された現在アクティブな抽選モデルのマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.UpdateCurrentLotteryMaster(
&lottery.UpdateCurrentLotteryMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Mode: pointy.String("direct"),
Settings: pointy.String("{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\UpdateCurrentLotteryMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->updateCurrentLotteryMaster(
(new UpdateCurrentLotteryMasterRequest())
->withNamespaceName("namespace-0001")
->withMode("direct")
->withSettings("{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.UpdateCurrentLotteryMasterRequest;
import io.gs2.lottery.result.UpdateCurrentLotteryMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
UpdateCurrentLotteryMasterResult result = client.updateCurrentLotteryMaster(
new UpdateCurrentLotteryMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\n }\n ]\n}")
.withUploadToken(null)
);
CurrentLotteryMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentLotteryMaster(
new Gs2.Gs2Lottery.Request.UpdateCurrentLotteryMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMode("direct")
.WithSettings("{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.updateCurrentLotteryMaster(
new Gs2Lottery.UpdateCurrentLotteryMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\n }\n ]\n}")
.withUploadToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.update_current_lottery_master(
lottery.UpdateCurrentLotteryMasterRequest()
.with_namespace_name('namespace-0001')
.with_mode('direct')
.with_settings('{\n "version": "2019-02-21",\n "lotteryModels": [\n {\n "name": "gacha",\n "metadata": "GACHA",\n "mode": "normal",\n "method": "prize_table",\n "prizeTableName": "gacha"\n },\n {\n "name": "gacha_ssr",\n "metadata": "SSR",\n "mode": "normal",\n "method": "prize_table",\n "prizeTableName": "gacha-ssr"\n },\n {\n "name": "gacha_sr",\n "metadata": "SR",\n "mode": "normal",\n "method": "prize_table",\n "prizeTableName": "gacha-sr"\n },\n {\n "name": "gacha_r",\n "metadata": "R",\n "mode": "normal",\n "method": "prize_table",\n "prizeTableName": "gacha-r"\n },\n {\n "name": "box",\n "metadata": "BOX",\n "mode": "box",\n "method": "prize_table",\n "prizeTableName": "box"\n }\n ],\n "prizeTables": [\n {\n "name": "gacha",\n "metadata": "SSR",\n "prizes": [\n {\n "prizeId": "prize-1",\n "type": "prize_table",\n "prizeTableName": "gacha-ssr",\n "weight": 5\n },\n {\n "prizeId": "prize-2",\n "type": "prize_table",\n "prizeTableName": "gacha-sr",\n "weight": 15\n },\n {\n "prizeId": "prize-3",\n "type": "prize_table",\n "prizeTableName": "gacha-r",\n "weight": 80\n }\n ]\n },\n {\n "name": "gacha-ssr",\n "metadata": "SSR",\n "prizes": [\n {\n "prizeId": "prize-4",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 1\n },\n {\n "prizeId": "prize-5",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 2\n },\n {\n "prizeId": "prize-6",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 3\n }\n ]\n },\n {\n "name": "gacha-sr",\n "metadata": "SR",\n "prizes": [\n {\n "prizeId": "prize-7",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 10\n },\n {\n "prizeId": "prize-8",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 20\n },\n {\n "prizeId": "prize-9",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 30\n }\n ]\n },\n {\n "name": "gacha-r",\n "metadata": "R",\n "prizes": [\n {\n "prizeId": "prize-10",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 100\n },\n {\n "prizeId": "prize-11",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 200\n },\n {\n "prizeId": "prize-12",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 300\n }\n ]\n },\n {\n "name": "box",\n "metadata": "BOX",\n "prizes": [\n {\n "prizeId": "prize-13",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 30\n },\n {\n "prizeId": "prize-14",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 20\n },\n {\n "prizeId": "prize-15",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 10\n }\n ]\n }\n ]\n}')
.with_upload_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.update_current_lottery_master({
namespaceName="namespace-0001",
mode="direct",
settings="{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\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('lottery')
api_result_handler = client.update_current_lottery_master_async({
namespaceName="namespace-0001",
mode="direct",
settings="{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\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;
```
---
### updateCurrentLotteryMasterFromGitHub
現在アクティブな抽選モデルのマスターデータをGitHubから更新
指定された GitHub リポジトリからマスターデータを取得して、現在アクティブな抽選モデルのマスターデータを更新します。
GS2-Key に保存された API キーが認証に使用され、チェックアウトするブランチ、タグ、またはコミットハッシュを指定できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| checkoutSetting | [GitHubCheckoutSetting](#githubcheckoutsetting) | | ✓| | | GitHubからマスターデータをチェックアウトする設定 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentLotteryMaster](#currentlotterymaster) | 更新された現在アクティブな抽選モデルのマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.UpdateCurrentLotteryMasterFromGitHub(
&lottery.UpdateCurrentLotteryMasterFromGitHubRequest {
NamespaceName: pointy.String("namespace-0001"),
CheckoutSetting: &lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\UpdateCurrentLotteryMasterFromGitHubRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->updateCurrentLotteryMasterFromGitHub(
(new UpdateCurrentLotteryMasterFromGitHubRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.UpdateCurrentLotteryMasterFromGitHubRequest;
import io.gs2.lottery.result.UpdateCurrentLotteryMasterFromGitHubResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
UpdateCurrentLotteryMasterFromGitHubResult result = client.updateCurrentLotteryMasterFromGitHub(
new UpdateCurrentLotteryMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
CurrentLotteryMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentLotteryMasterFromGitHub(
new Gs2.Gs2Lottery.Request.UpdateCurrentLotteryMasterFromGitHubRequest()
.WithNamespaceName("namespace-0001")
.WithCheckoutSetting(new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.updateCurrentLotteryMasterFromGitHub(
new Gs2Lottery.UpdateCurrentLotteryMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.update_current_lottery_master_from_git_hub(
lottery.UpdateCurrentLotteryMasterFromGitHubRequest()
.with_namespace_name('namespace-0001')
.with_checkout_setting(lottery.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('lottery')
api_result = client.update_current_lottery_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('lottery')
api_result_handler = client.update_current_lottery_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;
```
---
### describeLotteryModelMasters
抽選モデルマスターの一覧を取得
指定されたネームスペースの抽選モデルマスターのページネーション付きリストを取得します。
名前の接頭辞でフィルタリングできます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| namePrefix | string | | | | ~ 64文字 | 抽選モデル名のフィルター接頭辞 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<LotteryModelMaster>](#lotterymodelmaster) | 抽選モデルマスターのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeLotteryModelMasters(
&lottery.DescribeLotteryModelMastersRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeLotteryModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeLotteryModelMasters(
(new DescribeLotteryModelMastersRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeLotteryModelMastersRequest;
import io.gs2.lottery.result.DescribeLotteryModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeLotteryModelMastersResult result = client.describeLotteryModelMasters(
new DescribeLotteryModelMastersRequest()
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeLotteryModelMasters(
new Gs2.Gs2Lottery.Request.DescribeLotteryModelMastersRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeLotteryModelMasters(
new Gs2Lottery.DescribeLotteryModelMastersRequest()
.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_lottery_model_masters(
lottery.DescribeLotteryModelMastersRequest()
.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('lottery')
api_result = client.describe_lottery_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('lottery')
api_result_handler = client.describe_lottery_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;
```
---
### createLotteryModelMaster
抽選モデルマスターを新規作成
指定された設定で新しい抽選モデルマスターを作成します。
モードは 'normal'（復元抽選：排出済みの景品も再度排出される）または 'box'（非復元抽選：排出された景品はプールから除外される）を指定できます。
方式は 'prizeTable'（事前定義された排出確率テーブルを使用）または 'script'（GS2-Script で動的に景品を決定）を指定できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string | | ✓| | ~ 128文字 | 抽選モデル名
抽選モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| mode | 文字列列挙型
enum {
"normal",
"box"
}
| | ✓| | | 抽選モード
景品の抽選方式を選択します。"normal" は毎回一定の確率で抽選を行います（景品は繰り返し排出されます）。"box" は仮想的な箱にあらかじめ定義された数量の景品を入れ、抽選するたびに箱から景品を取り出します（すべての景品が最終的に排出されることが保証されます）。"normal": 通常抽選 / "box": ボックス抽選 / |
| method | 文字列列挙型
enum {
"prize_table",
"script"
}
| | ✓| | | 抽選方法
排出確率テーブルの参照方法を決定します。"prize_table" は静的に指定された排出確率テーブルを使用します。
"script" はGS2-Scriptを使用して抽選時に動的に排出確率テーブルを選択し、10連ガチャで1回だけ異なる排出確率テーブルを適用するなどのシナリオを実現できます。"prize_table": 静的な排出確率テーブル / "script": GS2-Script による動的な排出確率テーブル / |
| prizeTableName | string | {method} == "prize_table" | ✓※| | ~ 128文字 | 排出確率テーブルの名前
この抽選モデルで使用する排出確率テーブルの名前です。抽選方法が "prize_table" の場合に必須です。
※ method が "prize_table" であれば必須 |
| choicePrizeTableScriptId | string | {method} == "script" | ✓※| | ~ 1024文字 | 排出確率テーブルを決定する GS2-Script のスクリプトGRN
Script トリガーリファレンス - [`choicePrizeTable`](../script/#choiceprizetable)
※ method が "script" であれば必須 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | 作成した抽選モデルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CreateLotteryModelMaster(
&lottery.CreateLotteryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("lotteryModel-0001"),
Description: nil,
Metadata: nil,
Mode: pointy.String("normal"),
Method: pointy.String("prize_table"),
PrizeTableName: pointy.String("prizeTable-0001"),
ChoicePrizeTableScriptId: 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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CreateLotteryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->createLotteryModelMaster(
(new CreateLotteryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withName("lotteryModel-0001")
->withDescription(null)
->withMetadata(null)
->withMode("normal")
->withMethod("prize_table")
->withPrizeTableName("prizeTable-0001")
->withChoicePrizeTableScriptId(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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CreateLotteryModelMasterRequest;
import io.gs2.lottery.result.CreateLotteryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
CreateLotteryModelMasterResult result = client.createLotteryModelMaster(
new CreateLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("lotteryModel-0001")
.withDescription(null)
.withMetadata(null)
.withMode("normal")
.withMethod("prize_table")
.withPrizeTableName("prizeTable-0001")
.withChoicePrizeTableScriptId(null)
);
LotteryModelMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateLotteryModelMaster(
new Gs2.Gs2Lottery.Request.CreateLotteryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("lotteryModel-0001")
.WithDescription(null)
.WithMetadata(null)
.WithMode("normal")
.WithMethod("prize_table")
.WithPrizeTableName("prizeTable-0001")
.WithChoicePrizeTableScriptId(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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.createLotteryModelMaster(
new Gs2Lottery.CreateLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("lotteryModel-0001")
.withDescription(null)
.withMetadata(null)
.withMode("normal")
.withMethod("prize_table")
.withPrizeTableName("prizeTable-0001")
.withChoicePrizeTableScriptId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.create_lottery_model_master(
lottery.CreateLotteryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('lotteryModel-0001')
.with_description(None)
.with_metadata(None)
.with_mode('normal')
.with_method('prize_table')
.with_prize_table_name('prizeTable-0001')
.with_choice_prize_table_script_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.create_lottery_model_master({
namespaceName="namespace-0001",
name="lotteryModel-0001",
description=nil,
metadata=nil,
mode="normal",
method="prize_table",
prizeTableName="prizeTable-0001",
choicePrizeTableScriptId=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('lottery')
api_result_handler = client.create_lottery_model_master_async({
namespaceName="namespace-0001",
name="lotteryModel-0001",
description=nil,
metadata=nil,
mode="normal",
method="prize_table",
prizeTableName="prizeTable-0001",
choicePrizeTableScriptId=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;
```
---
### getLotteryModelMaster
抽選モデルマスターを取得
指定された抽選モデルマスターのモード（normal/box）、抽選方式（prizeTable/script）、関連する排出確率テーブルまたはスクリプトの設定を含む情報を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| lotteryName | string | | ✓| | ~ 128文字 | 抽選モデル名
抽選モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | 抽選モデルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetLotteryModelMaster(
&lottery.GetLotteryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lotteryModel-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetLotteryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getLotteryModelMaster(
(new GetLotteryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lotteryModel-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetLotteryModelMasterRequest;
import io.gs2.lottery.result.GetLotteryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetLotteryModelMasterResult result = client.getLotteryModelMaster(
new GetLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
LotteryModelMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetLotteryModelMaster(
new Gs2.Gs2Lottery.Request.GetLotteryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lotteryModel-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getLotteryModelMaster(
new Gs2Lottery.GetLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_lottery_model_master(
lottery.GetLotteryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lotteryModel-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_lottery_model_master({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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('lottery')
api_result_handler = client.get_lottery_model_master_async({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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;
```
---
### updateLotteryModelMaster
抽選モデルマスターを更新
指定された抽選モデルマスターを更新します。説明、メタデータ、モード（normal/box）、抽選方式（prizeTable/script）、排出確率テーブル名、スクリプト設定を変更できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| lotteryName | string | | ✓| | ~ 128文字 | 抽選モデル名
抽選モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| mode | 文字列列挙型
enum {
"normal",
"box"
}
| | ✓| | | 抽選モード
景品の抽選方式を選択します。"normal" は毎回一定の確率で抽選を行います（景品は繰り返し排出されます）。"box" は仮想的な箱にあらかじめ定義された数量の景品を入れ、抽選するたびに箱から景品を取り出します（すべての景品が最終的に排出されることが保証されます）。"normal": 通常抽選 / "box": ボックス抽選 / |
| method | 文字列列挙型
enum {
"prize_table",
"script"
}
| | ✓| | | 抽選方法
排出確率テーブルの参照方法を決定します。"prize_table" は静的に指定された排出確率テーブルを使用します。
"script" はGS2-Scriptを使用して抽選時に動的に排出確率テーブルを選択し、10連ガチャで1回だけ異なる排出確率テーブルを適用するなどのシナリオを実現できます。"prize_table": 静的な排出確率テーブル / "script": GS2-Script による動的な排出確率テーブル / |
| prizeTableName | string | {method} == "prize_table" | ✓※| | ~ 128文字 | 排出確率テーブルの名前
この抽選モデルで使用する排出確率テーブルの名前です。抽選方法が "prize_table" の場合に必須です。
※ method が "prize_table" であれば必須 |
| choicePrizeTableScriptId | string | {method} == "script" | ✓※| | ~ 1024文字 | 排出確率テーブルを決定する GS2-Script のスクリプトGRN
Script トリガーリファレンス - [`choicePrizeTable`](../script/#choiceprizetable)
※ method が "script" であれば必須 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | 更新した抽選モデルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.UpdateLotteryModelMaster(
&lottery.UpdateLotteryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lotteryModel-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("METADATA1"),
Mode: pointy.String("box"),
Method: pointy.String("prize_table"),
PrizeTableName: pointy.String("prizeTable-0002"),
ChoicePrizeTableScriptId: 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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\UpdateLotteryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->updateLotteryModelMaster(
(new UpdateLotteryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lotteryModel-0001")
->withDescription("description1")
->withMetadata("METADATA1")
->withMode("box")
->withMethod("prize_table")
->withPrizeTableName("prizeTable-0002")
->withChoicePrizeTableScriptId(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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.UpdateLotteryModelMasterRequest;
import io.gs2.lottery.result.UpdateLotteryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
UpdateLotteryModelMasterResult result = client.updateLotteryModelMaster(
new UpdateLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
.withDescription("description1")
.withMetadata("METADATA1")
.withMode("box")
.withMethod("prize_table")
.withPrizeTableName("prizeTable-0002")
.withChoicePrizeTableScriptId(null)
);
LotteryModelMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateLotteryModelMaster(
new Gs2.Gs2Lottery.Request.UpdateLotteryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lotteryModel-0001")
.WithDescription("description1")
.WithMetadata("METADATA1")
.WithMode("box")
.WithMethod("prize_table")
.WithPrizeTableName("prizeTable-0002")
.WithChoicePrizeTableScriptId(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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.updateLotteryModelMaster(
new Gs2Lottery.UpdateLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
.withDescription("description1")
.withMetadata("METADATA1")
.withMode("box")
.withMethod("prize_table")
.withPrizeTableName("prizeTable-0002")
.withChoicePrizeTableScriptId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.update_lottery_model_master(
lottery.UpdateLotteryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lotteryModel-0001')
.with_description('description1')
.with_metadata('METADATA1')
.with_mode('box')
.with_method('prize_table')
.with_prize_table_name('prizeTable-0002')
.with_choice_prize_table_script_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.update_lottery_model_master({
namespaceName="namespace-0001",
lotteryName="lotteryModel-0001",
description="description1",
metadata="METADATA1",
mode="box",
method="prize_table",
prizeTableName="prizeTable-0002",
choicePrizeTableScriptId=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('lottery')
api_result_handler = client.update_lottery_model_master_async({
namespaceName="namespace-0001",
lotteryName="lotteryModel-0001",
description="description1",
metadata="METADATA1",
mode="box",
method="prize_table",
prizeTableName="prizeTable-0002",
choicePrizeTableScriptId=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;
```
---
### deleteLotteryModelMaster
抽選モデルマスターを削除
指定された抽選モデルマスターを削除します。
次のマスターデータ更新まで、現在アクティブなマスターデータには影響しません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| lotteryName | string | | ✓| | ~ 128文字 | 抽選モデル名
抽選モデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | 削除した抽選モデルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DeleteLotteryModelMaster(
&lottery.DeleteLotteryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lotteryModel-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DeleteLotteryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->deleteLotteryModelMaster(
(new DeleteLotteryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lotteryModel-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DeleteLotteryModelMasterRequest;
import io.gs2.lottery.result.DeleteLotteryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DeleteLotteryModelMasterResult result = client.deleteLotteryModelMaster(
new DeleteLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
LotteryModelMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteLotteryModelMaster(
new Gs2.Gs2Lottery.Request.DeleteLotteryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lotteryModel-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.deleteLotteryModelMaster(
new Gs2Lottery.DeleteLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.delete_lottery_model_master(
lottery.DeleteLotteryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lotteryModel-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.delete_lottery_model_master({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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('lottery')
api_result_handler = client.delete_lottery_model_master_async({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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;
```
---
### describePrizeTableMasters
排出確率テーブルマスターの一覧を取得
指定されたネームスペースの排出確率テーブルマスターのページネーション付きリストを取得します。
名前の接頭辞でフィルタリングできます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| namePrefix | string | | | | ~ 64文字 | 排出確率テーブル名のフィルター接頭辞 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<PrizeTableMaster>](#prizetablemaster) | 排出確率テーブルマスターのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribePrizeTableMasters(
&lottery.DescribePrizeTableMastersRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribePrizeTableMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describePrizeTableMasters(
(new DescribePrizeTableMastersRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribePrizeTableMastersRequest;
import io.gs2.lottery.result.DescribePrizeTableMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribePrizeTableMastersResult result = client.describePrizeTableMasters(
new DescribePrizeTableMastersRequest()
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribePrizeTableMasters(
new Gs2.Gs2Lottery.Request.DescribePrizeTableMastersRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describePrizeTableMasters(
new Gs2Lottery.DescribePrizeTableMastersRequest()
.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_prize_table_masters(
lottery.DescribePrizeTableMastersRequest()
.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('lottery')
api_result = client.describe_prize_table_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('lottery')
api_result_handler = client.describe_prize_table_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;
```
---
### createPrizeTableMaster
排出確率テーブルマスターを新規作成
指定された景品設定で新しい排出確率テーブルマスターを作成します。
各景品エントリは、景品ID、タイプ、入手アクション、排出重み、およびオプションの数量制限を定義します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string | | ✓| | ~ 128文字 | 排出確率テーブル名
排出確率テーブル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 128文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| prizes | [List<Prize>](#prize) | | ✓| | 1 ~ 100 items | 景品リスト
この排出確率テーブル内の景品リストです。各景品は排出重み（確率）、排出時に実行するアクション、およびオプションの排出回数制限を定義します。各景品の実際の排出確率は、その重みをテーブル内の全景品の重みの合計で割って算出されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | 作成した排出確率テーブルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CreatePrizeTableMaster(
&lottery.CreatePrizeTableMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("prizeTable-0001"),
Description: nil,
Metadata: nil,
Prizes: []lottery.Prize{
lottery.Prize{
PrizeId: pointy.String("1"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-0001"),
},
},
Weight: pointy.Int32(1),
},
lottery.Prize{
PrizeId: pointy.String("2"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-0002"),
},
},
Weight: pointy.Int32(2),
},
lottery.Prize{
PrizeId: pointy.String("3"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-0003"),
},
},
Weight: pointy.Int32(3),
},
},
}
)
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CreatePrizeTableMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->createPrizeTableMaster(
(new CreatePrizeTableMasterRequest())
->withNamespaceName("namespace-0001")
->withName("prizeTable-0001")
->withDescription(null)
->withMetadata(null)
->withPrizes([
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("1")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-0001"),
])
->withWeight(1),
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("2")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-0002"),
])
->withWeight(2),
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("3")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-0003"),
])
->withWeight(3),
])
);
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CreatePrizeTableMasterRequest;
import io.gs2.lottery.result.CreatePrizeTableMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
CreatePrizeTableMasterResult result = client.createPrizeTableMaster(
new CreatePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withName("prizeTable-0001")
.withDescription(null)
.withMetadata(null)
.withPrizes(Arrays.asList(
new io.gs2.lottery.model.Prize()
.withPrizeId("1")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0001")
))
.withWeight(1),
new io.gs2.lottery.model.Prize()
.withPrizeId("2")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0002")
))
.withWeight(2),
new io.gs2.lottery.model.Prize()
.withPrizeId("3")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0003")
))
.withWeight(3)
))
);
PrizeTableMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreatePrizeTableMaster(
new Gs2.Gs2Lottery.Request.CreatePrizeTableMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("prizeTable-0001")
.WithDescription(null)
.WithMetadata(null)
.WithPrizes(new Gs2.Gs2Lottery.Model.Prize[] {
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("1")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-0001"),
})
.WithWeight(1),
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("2")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-0002"),
})
.WithWeight(2),
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("3")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-0003"),
})
.WithWeight(3),
}),
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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.createPrizeTableMaster(
new Gs2Lottery.CreatePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withName("prizeTable-0001")
.withDescription(null)
.withMetadata(null)
.withPrizes([
new Gs2Lottery.model.Prize()
.withPrizeId("1")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0001"),
])
.withWeight(1),
new Gs2Lottery.model.Prize()
.withPrizeId("2")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0002"),
])
.withWeight(2),
new Gs2Lottery.model.Prize()
.withPrizeId("3")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0003"),
])
.withWeight(3),
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.create_prize_table_master(
lottery.CreatePrizeTableMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('prizeTable-0001')
.with_description(None)
.with_metadata(None)
.with_prizes([
lottery.Prize()
.with_prize_id('1')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-0001'),
])
.with_weight(1),
lottery.Prize()
.with_prize_id('2')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-0002'),
])
.with_weight(2),
lottery.Prize()
.with_prize_id('3')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-0003'),
])
.with_weight(3),
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.create_prize_table_master({
namespaceName="namespace-0001",
name="prizeTable-0001",
description=nil,
metadata=nil,
prizes={
{
prizeId="1",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0001",
}
},
weight=1,
},
{
prizeId="2",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0002",
}
},
weight=2,
},
{
prizeId="3",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0003",
}
},
weight=3,
}
},
})
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('lottery')
api_result_handler = client.create_prize_table_master_async({
namespaceName="namespace-0001",
name="prizeTable-0001",
description=nil,
metadata=nil,
prizes={
{
prizeId="1",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0001",
}
},
weight=1,
},
{
prizeId="2",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0002",
}
},
weight=2,
},
{
prizeId="3",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0003",
}
},
weight=3,
}
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getPrizeTableMaster
排出確率テーブルマスターを取得
指定された排出確率テーブルマスターの景品リスト、排出重み、タイプ、数量制限を含む情報を取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名
排出確率テーブル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | 排出確率テーブルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetPrizeTableMaster(
&lottery.GetPrizeTableMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetPrizeTableMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getPrizeTableMaster(
(new GetPrizeTableMasterRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetPrizeTableMasterRequest;
import io.gs2.lottery.result.GetPrizeTableMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetPrizeTableMasterResult result = client.getPrizeTableMaster(
new GetPrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
PrizeTableMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetPrizeTableMaster(
new Gs2.Gs2Lottery.Request.GetPrizeTableMasterRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getPrizeTableMaster(
new Gs2Lottery.GetPrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_prize_table_master(
lottery.GetPrizeTableMasterRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_prize_table_master({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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('lottery')
api_result_handler = client.get_prize_table_master_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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;
```
---
### updatePrizeTableMaster
排出確率テーブルマスターを更新
指定された排出確率テーブルマスターを更新します。説明、メタデータ、および景品リストの排出重みや数量制限を変更できます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名
排出確率テーブル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 128文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| prizes | [List<Prize>](#prize) | | ✓| | 1 ~ 100 items | 景品リスト
この排出確率テーブル内の景品リストです。各景品は排出重み（確率）、排出時に実行するアクション、およびオプションの排出回数制限を定義します。各景品の実際の排出確率は、その重みをテーブル内の全景品の重みの合計で割って算出されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | 更新した排出確率テーブルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.UpdatePrizeTableMaster(
&lottery.UpdatePrizeTableMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("METADATA1"),
Prizes: []lottery.Prize{
lottery.Prize{
PrizeId: pointy.String("4"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-1001"),
},
},
Weight: pointy.Int32(2),
},
lottery.Prize{
PrizeId: pointy.String("5"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-1002"),
},
},
Weight: pointy.Int32(3),
},
lottery.Prize{
PrizeId: pointy.String("6"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-1003"),
},
},
Weight: pointy.Int32(4),
},
},
}
)
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\UpdatePrizeTableMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->updatePrizeTableMaster(
(new UpdatePrizeTableMasterRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withDescription("description1")
->withMetadata("METADATA1")
->withPrizes([
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("4")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-1001"),
])
->withWeight(2),
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("5")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-1002"),
])
->withWeight(3),
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("6")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-1003"),
])
->withWeight(4),
])
);
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.UpdatePrizeTableMasterRequest;
import io.gs2.lottery.result.UpdatePrizeTableMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
UpdatePrizeTableMasterResult result = client.updatePrizeTableMaster(
new UpdatePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withDescription("description1")
.withMetadata("METADATA1")
.withPrizes(Arrays.asList(
new io.gs2.lottery.model.Prize()
.withPrizeId("4")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1001")
))
.withWeight(2),
new io.gs2.lottery.model.Prize()
.withPrizeId("5")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1002")
))
.withWeight(3),
new io.gs2.lottery.model.Prize()
.withPrizeId("6")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1003")
))
.withWeight(4)
))
);
PrizeTableMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdatePrizeTableMaster(
new Gs2.Gs2Lottery.Request.UpdatePrizeTableMasterRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithDescription("description1")
.WithMetadata("METADATA1")
.WithPrizes(new Gs2.Gs2Lottery.Model.Prize[] {
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("4")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-1001"),
})
.WithWeight(2),
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("5")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-1002"),
})
.WithWeight(3),
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("6")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-1003"),
})
.WithWeight(4),
}),
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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.updatePrizeTableMaster(
new Gs2Lottery.UpdatePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withDescription("description1")
.withMetadata("METADATA1")
.withPrizes([
new Gs2Lottery.model.Prize()
.withPrizeId("4")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1001"),
])
.withWeight(2),
new Gs2Lottery.model.Prize()
.withPrizeId("5")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1002"),
])
.withWeight(3),
new Gs2Lottery.model.Prize()
.withPrizeId("6")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1003"),
])
.withWeight(4),
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.update_prize_table_master(
lottery.UpdatePrizeTableMasterRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_description('description1')
.with_metadata('METADATA1')
.with_prizes([
lottery.Prize()
.with_prize_id('4')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-1001'),
])
.with_weight(2),
lottery.Prize()
.with_prize_id('5')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-1002'),
])
.with_weight(3),
lottery.Prize()
.with_prize_id('6')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-1003'),
])
.with_weight(4),
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.update_prize_table_master({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
description="description1",
metadata="METADATA1",
prizes={
{
prizeId="4",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1001",
}
},
weight=2,
},
{
prizeId="5",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1002",
}
},
weight=3,
},
{
prizeId="6",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1003",
}
},
weight=4,
}
},
})
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('lottery')
api_result_handler = client.update_prize_table_master_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
description="description1",
metadata="METADATA1",
prizes={
{
prizeId="4",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1001",
}
},
weight=2,
},
{
prizeId="5",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1002",
}
},
weight=3,
},
{
prizeId="6",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1003",
}
},
weight=4,
}
},
})
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;
```
---
### deletePrizeTableMaster
排出確率テーブルマスターを削除
指定された排出確率テーブルマスターを削除します。
次のマスターデータ更新まで、現在アクティブなマスターデータには影響しません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| prizeTableName | string | | ✓| | ~ 128文字 | 排出確率テーブル名
排出確率テーブル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | 削除した排出確率テーブルマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DeletePrizeTableMaster(
&lottery.DeletePrizeTableMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DeletePrizeTableMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->deletePrizeTableMaster(
(new DeletePrizeTableMasterRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DeletePrizeTableMasterRequest;
import io.gs2.lottery.result.DeletePrizeTableMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DeletePrizeTableMasterResult result = client.deletePrizeTableMaster(
new DeletePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
PrizeTableMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeletePrizeTableMaster(
new Gs2.Gs2Lottery.Request.DeletePrizeTableMasterRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.deletePrizeTableMaster(
new Gs2Lottery.DeletePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.delete_prize_table_master(
lottery.DeletePrizeTableMasterRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.delete_prize_table_master({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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('lottery')
api_result_handler = client.delete_prize_table_master_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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;
```
---