> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Showcase SDK API リファレンス
各種プログラミング言語向け GS2-Showcase SDK の モデルの仕様 と API のリファレンス
## モデル
### Namespace
ネームスペース
ネームスペースは、一つのプロジェクト内で同じサービスを異なる用途で複数利用するためのエンティティです。
GS2 の各サービスはネームスペース単位で管理されます。ネームスペースが異なれば、同じサービスでも完全に独立したデータ空間として扱われます。
そのため、各サービスの利用を開始するにあたってネームスペースを作成する必要があります。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024文字 | ネームスペースGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | ✓ | | | トランザクション設定
陳列棚操作時のトランザクションの処理方法を制御する設定です。 |
| buyScript | [ScriptSetting](#scriptsetting) | | | | | 購入を実行しようとしたときに実行するスクリプトの設定
Script トリガーリファレンス - [`buy`](../script/#buy) |
| 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 - ネームスペース
---
### ScriptSetting
スクリプト設定
GS2 ではマイクロサービスのイベントに関連づけて、カスタムスクリプトを実行することができます。
このモデルは、スクリプトの実行をトリガーするための設定を保持します。
スクリプトの実行方式は大きく2種類あり、それは「同期実行」と「非同期実行」です。
同期実行は、スクリプトの実行が完了するまで処理がブロックされます。
代わりに、スクリプトの実行結果を使って API の実行を止めたり、API のレスポンス内容を制御することができます。
一方、非同期実行ではスクリプトの完了を待つために処理がブロックされることはありません。
ただし、スクリプトの実行結果を利用して API の実行を停止したり、API の応答内容を変更することはできません。
非同期実行は API の応答フローに影響を与えないため、原則として非同期実行を推奨します。
非同期実行には実行方式が2種類あり、GS2-Script と Amazon EventBridge があります。
Amazon EventBridge を使用することで、Lua 以外の言語で処理を記述することができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| triggerScriptId | string | | | | ~ 1024文字 | API 実行時に同期的に実行される GS2-Script のスクリプトGRN
「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。 |
| doneTriggerTargetType | 文字列列挙型
enum {
"none",
"gs2_script",
"aws"
}
| | | "none" | | 非同期スクリプトの実行方法
非同期実行で使用するスクリプトの種類を指定します。
「非同期実行のスクリプトを使用しない(none)」「GS2-Scriptを使用する(gs2_script)」「Amazon EventBridgeを使用する(aws)」が選択できます。"none": なし / "gs2_script": GS2-Script / "aws": Amazon EventBridge / |
| doneTriggerScriptId | string | {doneTriggerTargetType} == "gs2_script" | | | ~ 1024文字 | 非同期実行する GS2-Script スクリプトGRN
「grn:gs2:」ではじまる GRN 形式のIDで指定する必要があります。
※ doneTriggerTargetType が "gs2_script" であれば 有効 |
| doneTriggerQueueNamespaceId | string | {doneTriggerTargetType} == "gs2_script" | | | ~ 1024文字 | 非同期実行スクリプトを実行する GS2-JobQueue ネームスペースGRN
非同期実行スクリプトを直接実行するのではなく、GS2-JobQueue を経由する場合は GS2-JobQueue のネームスペースGRN を指定します。
GS2-JobQueue を利用する理由は多くはありませんので、特に理由がなければ指定する必要はありません。
※ doneTriggerTargetType が "gs2_script" であれば 有効 |
**関連するメソッド:**
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" であれば 必須 |
**関連するメソッド:**
updateCurrentShowcaseMasterFromGitHub - 現在アクティブな陳列棚のマスターデータをGitHubから更新
---
### Showcase
陳列棚
`陳列棚`には陳列する商品を定義できます。
また、`陳列棚`の商品の販売期間を設定することができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| showcaseId | string | | ※ | | ~ 1024文字 | 陳列棚GRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | 陳列棚名
陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| salesPeriodEventId | string | | | | ~ 1024文字 | 陳列棚の販売期間を設定した GS2-Schedule のイベントGRN
この陳列棚全体の販売期間を制御します。指定した場合、関連する GS2-Schedule のイベント期間中のみ陳列棚が利用可能になります。イベントが有効でない場合、陳列棚は空で返されます。 |
| displayItems | [List<DisplayItem>](#displayitem) | | | [] | 1 ~ 1000 items | 陳列する商品リスト
この陳列棚に陳列される商品のリストです。各陳列商品は単一の商品または商品グループのいずれかです。販売期間イベントが終了または無効な商品は、陳列棚の取得時に自動的にフィルタリングされます。 |
**関連するメソッド:**
describeShowcases - 陳列棚の一覧を取得
describeShowcasesByUserId - ユーザーIDを指定して陳列棚の一覧を取得
getShowcase - 陳列棚を取得
getShowcaseByUserId - ユーザーIDを指定して陳列棚を取得
---
### DisplayItem
陳列する商品
陳列棚に表示される商品です。単一の商品または商品グループのいずれかを参照できます。各陳列商品には、陳列棚全体の販売期間とは独立して GS2-Schedule イベントによる個別の販売期間を設定できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| displayItemId | string | | ✓ | UUID | ~ 128文字 | 陳列商品ID
陳列商品の一意な名前を保持します。
省略するとシステムによって UUID（Universally Unique Identifier）フォーマットで自動的に割り当てられます。 |
| type | 文字列列挙型
enum {
"salesItem",
"salesItemGroup"
}
| | ✓ | | | 種類
表示する商品の種類です。「salesItem」は固定の対価と報酬を持つ単一商品です。「salesItemGroup」は複数の商品を順番に評価する商品グループで、ステップアップ価格や初回限定割引などに使用されます。"salesItem": 商品 / "salesItemGroup": 商品グループ / |
| salesItem | [SalesItem](#salesitem) | {type} == "salesItem" | ✓※ | | | 商品
※ type が "salesItem" であれば 必須 |
| salesItemGroup | [SalesItemGroup](#salesitemgroup) | {type} == "salesItemGroup" | ✓※ | | | 商品グループ
※ type が "salesItemGroup" であれば 必須 |
| salesPeriodEventId | string | | | | ~ 1024文字 | この陳列商品の販売期間を設定した GS2-Schedule のイベントGRN
この個別の陳列商品の販売期間を制御します。指定した場合、関連する GS2-Schedule のイベント期間中のみ陳列棚に表示されます。陳列棚全体の販売期間とは独立して動作します。 |
**関連するモデル:**
Showcase - 陳列棚
---
### RandomShowcase
ランダム陳列棚
ランダム陳列棚は、指定した周期で入れ替わるランダムに選別された商品が陳列される陳列棚のモデルです。
選別される商品は、商品プールに登録された商品から指定数量が、商品ごとに設定された重みに基づいてランダムに選択されます。
ランダム陳列棚には GS2-Schedule のイベントを関連づけることで、販売期間を設定することができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| randomShowcaseId | string | | ※ | | ~ 1024文字 | ランダム陳列棚GRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| maximumNumberOfChoice | int | | ✓ | | 1 ~ 100 | 選出される商品の最大数
各ローテーション期間に商品プールからランダムに抽選される商品の数です。重み付きランダム選択で重複なく抽選されるため、1回のローテーションで同じ商品が2回表示されることはありません。 |
| displayItems | [List<RandomDisplayItemModel>](#randomdisplayitemmodel) | | | [] | 1 ~ 100 items | 選出対象の陳列商品リスト
商品がランダムに抽選される候補アイテムのプールです。各アイテムには選択確率を決定する重みと、ローテーション全体で表示可能な回数を制限する在庫数があります。 |
| baseTimestamp | long | | ✓ | | | 陳列する商品を再抽選の基準時間
ローテーション境界の計算に使用される基準タイムスタンプです。この基準時間から一定間隔（resetIntervalHours）ごとに商品の再抽選が行われます。過去の時刻を指定する必要があります。 |
| resetIntervalHours | int | | ✓ | | 1 ~ 168 | 陳列する商品を再抽選する間隔（時）
各商品ローテーション間の時間数です。baseTimestamp を基準として間隔が経過すると、新しい乱数シードで陳列商品が再抽選されます。1〜168時間（1週間）の範囲で設定できます。 |
| salesPeriodEventId | string | | | | ~ 1024文字 | 陳列棚の販売期間を設定した GS2-Schedule のイベントGRN
このランダム陳列棚全体の販売期間を制御します。指定した場合、関連する GS2-Schedule のイベント期間中のみ陳列棚が利用可能になります。 |
---
### RandomDisplayItem
ランダム陳列棚に陳列された商品
特定のユーザーに対してランダム陳列棚で抽選・表示された商品を表します。現在のローテーション期間における商品の対価、報酬、および購入回数の追跡情報を含みます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| showcaseName | string | | ✓ | | ~ 128文字 | ランダム陳列棚名 |
| name | string | | ✓ | UUID | ~ 128文字 | ランダム陳列商品名
ランダム陳列商品の一意な名前を保持します。
省略するとシステムによって UUID（Universally Unique Identifier）フォーマットで自動的に割り当てられます。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| verifyActions | [List<VerifyAction>](#verifyaction) | | | [] | 0 ~ 10 items | 検証アクションリスト |
| consumeActions | [List<ConsumeAction>](#consumeaction) | | | [] | 0 ~ 10 items | 消費アクションリスト |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | [] | 1 ~ 100 items | 入手アクションリスト |
| currentPurchaseCount | int | | ✓ | | 1 ~ 2147483646 | 現在の購入回数
現在のローテーション期間中にこの商品が購入された回数です。購入のたびに加算され、ローテーション期間が終了するとリセットされます。 |
| maximumPurchaseCount | int | | ✓ | | 1 ~ 2147483646 | 最大購入回数
現在のローテーション期間中にこの商品を購入できる最大回数です。currentPurchaseCount がこの値に達すると、次のローテーションまで購入できなくなります。 |
**関連するメソッド:**
describeRandomDisplayItems - ランダム陳列棚の商品一覧を取得
describeRandomDisplayItemsByUserId - ユーザーIDを指定してランダム陳列棚の商品一覧を取得
getRandomDisplayItem - ランダム陳列棚の商品を取得
getRandomDisplayItemByUserId - ユーザーIDを指定してランダム陳列棚の商品を取得
randomShowcaseBuy - ランダム陳列棚の商品を購入
randomShowcaseBuyByUserId - ユーザーIDを指定してランダム陳列棚の商品を購入
---
### RandomDisplayItemModel
ランダム陳列棚に陳列可能な商品
`weight` に商品を選別する確率を設定できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | UUID | ~ 128文字 | ランダム陳列商品ID
ランダム陳列商品の一意な名前を保持します。
省略するとシステムによって UUID（Universally Unique Identifier）フォーマットで自動的に割り当てられます。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| verifyActions | [List<VerifyAction>](#verifyaction) | | | [] | 0 ~ 10 items | 検証アクションリスト
このランダム陳列商品を購入する前に実行される前提条件チェックです。すべての検証アクションが成功した後に消費・入手アクションが処理されます。 |
| consumeActions | [List<ConsumeAction>](#consumeaction) | | | [] | 0 ~ 10 items | 消費アクションリスト
このランダム陳列商品の購入対価としてリソースを消費するアクションです。トランザクションの消費アクションとして実行されます。 |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | [] | 1 ~ 100 items | 入手アクションリスト
このランダム陳列商品の購入報酬としてリソースを付与するアクションです。トランザクションの入手アクションとして実行されます。 |
| stock | int | | ✓ | | 1 ~ 2147483646 | 在庫数
すべてのローテーションを通じてこの商品が抽選される最大回数です。在庫がゼロになると、以降の抽選から除外されます。ローテーション抽選時に商品が選択されると在庫が消費されます。 |
| weight | int | | ✓ | | 1 ~ 2147483646 | 排出重み
ランダム選択におけるこの商品の相対的な確率の重みです。重みが大きいほど抽選される確率が高くなります。実際の選択確率は、この商品の重みを対象となるすべての商品の重みの合計で割った値として計算されます。 |
**関連するモデル:**
RandomShowcase - ランダム陳列棚
RandomShowcaseMaster - ランダム陳列棚マスター
---
### SalesItem
商品
商品を購入するために必要となる対価と、商品を購入したときに得られる報酬を設定します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | 商品名
商品固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| verifyActions | [List<VerifyAction>](#verifyaction) | | | [] | 0 ~ 10 items | 検証アクションリスト
購入前に実行される前提条件チェックです。すべての検証アクションが成功した後に消費・入手アクションが処理されます。購入資格の条件チェックに使用できます。 |
| consumeActions | [List<ConsumeAction>](#consumeaction) | | | [] | 0 ~ 10 items | 消費アクションリスト
購入対価としてリソースを消費するアクションです。商品グループの購入回数制御のために GS2-Limit の CountUp アクションを含めることができます。 |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | [] | 1 ~ 100 items | 入手アクションリスト
購入報酬としてリソースを付与するアクションです。すべての消費アクションが正常に完了した後に実行されます。 |
**関連するメソッド:**
buy - 商品を購入
buyByUserId - ユーザーIDを指定して商品を購入
**関連するモデル:**
DisplayItem - 陳列する商品
SalesItemGroup - 商品グループ
---
### SalesItemGroup
商品グループ
商品グループは陳列棚に陳列するためのエンティティです。
商品グループには複数の商品を所属させることができ、所属している商品の先頭から順番に購入可能かを判定し、一番最初に購入可能だと判定された商品が実際に陳列されます。
初回のみ割引する商品や、ステップアップガチャのように購入回数によって商品の内容が変化する仕組みに使用できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | 商品グループ名
商品グループ固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| salesItems | [List<SalesItem>](#salesitem) | | | [] | 2 ~ 10 items | 商品グループに含める商品
このグループ内の商品の順序付きリストです。GS2-Limit カウンターを使って先頭から順に購入可能かを判定し、最初に購入可能と判定された商品が表示されます。いずれも該当しない場合、リストの最後の商品がフォールバックとして使用されます。 |
**関連するモデル:**
DisplayItem - 陳列する商品
---
### PurchaseCount
商品の購入回数
ローテーション期間内の特定のランダム陳列商品の購入回数を追跡します。購入時に加算され、購入が取り消された場合に減算されます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | 商品購入回数名
購入回数を追跡するランダム陳列商品の名前です。ランダム陳列棚内の陳列商品名に対応します。 |
| count | int | | ✓ | | 1 ~ 2147483646 | 購入回数
現在のローテーション期間中にこの商品が購入された回数です。商品ごとの最大購入回数制限の適用に使用されます。 |
---
### ConsumeAction
消費アクション
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 消費アクションで実行するアクションの種類 |
| request | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
**関連するモデル:**
RandomDisplayItem - ランダム陳列棚に陳列された商品
RandomDisplayItemModel - ランダム陳列棚に陳列可能な商品
SalesItem - 商品
SalesItemMaster - 商品マスター
---
### VerifyAction
検証アクション
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 検証アクションで実行するアクションの種類 |
| request | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
**関連するモデル:**
RandomDisplayItem - ランダム陳列棚に陳列された商品
RandomDisplayItemModel - ランダム陳列棚に陳列可能な商品
SalesItem - 商品
SalesItemMaster - 商品マスター
---
### AcquireAction
入手アクション
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 文字列列挙型
enum {
}
| | ✓ | | | 入手アクションで実行するアクションの種類 |
| request | string | | ✓ | | ~ 524288文字 | アクション実行時に使用されるリクエストのJSON文字列 |
**関連するモデル:**
RandomDisplayItem - ランダム陳列棚に陳列された商品
RandomDisplayItemModel - ランダム陳列棚に陳列可能な商品
SalesItem - 商品
SalesItemMaster - 商品マスター
---
### 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 | | トランザクション実行中にエラーが発生したかどうか |
**関連するメソッド:**
buy - 商品を購入
buyByUserId - ユーザーIDを指定して商品を購入
randomShowcaseBuy - ランダム陳列棚の商品を購入
randomShowcaseBuyByUserId - ユーザーIDを指定してランダム陳列棚の商品を購入
---
### CurrentShowcaseMaster
現在アクティブな陳列棚モデルのマスターデータ
現在ネームスペース内で有効な、陳列棚モデルの定義を記述したマスターデータです。
GS2ではマスターデータの管理にJSON形式のファイルを使用します。
ファイルをアップロードすることで、実際にサーバーに設定を反映することができます。
JSONファイルを作成する方法として、マネージメントコンソール内にマスターデータエディタを提供しています。
また、よりゲームの運営に相応しいツールを作成し、適切なフォーマットのJSONファイルを書き出すことでもサービスを利用可能です。
{{% alert title="Note" color="info" %}}
JSONファイルの形式については [GS2-Showcase マスターデータリファレンス](api_reference/showcase/master_data/) をご参照ください。
{{% /alert %}}
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024文字 | ネームスペースGRN
※ サーバーが自動で設定 |
| settings | string | | ✓ | | ~ 5242880 バイト (5MB) | マスターデータ |
**関連するメソッド:**
exportMaster - 陳列棚マスターを有効化可能なマスターデータ形式でエクスポート
getCurrentShowcaseMaster - 現在アクティブな陳列棚のマスターデータを取得
updateCurrentShowcaseMaster - 現在アクティブな陳列棚のマスターデータを更新
updateCurrentShowcaseMasterFromGitHub - 現在アクティブな陳列棚のマスターデータをGitHubから更新
---
### SalesItemMaster
商品マスター
商品マスターは、ゲーム内で使用される商品マスターの編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。
インポート・更新処理を行うことで、実際にゲームから参照される商品マスターとして反映されます。
商品を購入するために必要となる対価と、商品を購入したときに得られる報酬を設定します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| salesItemId | string | | ※ | | ~ 1024文字 | 商品マスターGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | 商品名
商品固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| verifyActions | [List<VerifyAction>](#verifyaction) | | | | 0 ~ 10 items | 検証アクションリスト
購入前に実行される前提条件チェックです。すべての検証アクションが成功した後に消費・入手アクションが処理されます。購入資格の条件チェックに使用できます。 |
| consumeActions | [List<ConsumeAction>](#consumeaction) | | | | 0 ~ 10 items | 消費アクションリスト
購入対価としてリソースを消費するアクションです。商品グループの購入回数制御のために GS2-Limit の CountUp アクションを含めることができます。 |
| acquireActions | [List<AcquireAction>](#acquireaction) | | ✓ | | 1 ~ 100 items | 入手アクションリスト
購入報酬としてリソースを付与するアクションです。すべての消費アクションが正常に完了した後に実行されます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeSalesItemMasters - 商品マスターの一覧を取得
createSalesItemMaster - 商品マスターを新規作成
getSalesItemMaster - 商品マスターを取得
updateSalesItemMaster - 商品マスターを更新
deleteSalesItemMaster - 商品マスターを削除
---
### SalesItemGroupMaster
商品グループマスター
商品グループマスターは、ゲーム内で使用される商品グループの編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。
インポート・更新処理を行うことで、実際にゲームから参照される商品グループとして反映されます。
商品グループは陳列棚に陳列するためのエンティティです。
商品グループには複数の商品を所属させることができ、所属している商品の先頭から順番に購入可能かを判定し、一番最初に購入可能だと判定された商品が実際に陳列されます。
初回のみ割引する商品や、ステップアップガチャのように購入回数によって商品の内容が変化する仕組みに使用できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| salesItemGroupId | string | | ※ | | ~ 1024文字 | 商品グループマスターGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | 商品グループ名
商品グループ固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| salesItemNames | List<string> | | ✓ | | 2 ~ 10 items | 商品グループに含める商品リスト
このグループ内の商品名の順序付きリストです。GS2-Limit カウンターを使って先頭から順に購入可能かを判定し、最初に購入可能と判定された商品が表示されます。いずれも該当しない場合、リストの最後の商品がフォールバックとして使用されます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeSalesItemGroupMasters - 商品グループマスターの一覧を取得
createSalesItemGroupMaster - 商品グループマスターを新規作成
getSalesItemGroupMaster - 商品グループマスターを取得
updateSalesItemGroupMaster - 商品グループマスターを更新
deleteSalesItemGroupMaster - 商品グループマスターを削除
---
### ShowcaseMaster
陳列棚マスター
陳列棚マスターは、ゲーム内で使用される`陳列棚`の編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。
インポート・更新処理を行うことで、実際にゲームから参照される`陳列棚`として反映されます。
`陳列棚`には販売期間を設定できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| showcaseId | string | | ※ | | ~ 1024文字 | 陳列棚マスターGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | 陳列棚名
陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| salesPeriodEventId | string | | | | ~ 1024文字 | 陳列棚の販売期間を設定した GS2-Schedule のイベントGRN
この陳列棚全体の販売期間を制御します。指定した場合、関連する GS2-Schedule のイベント期間中のみ陳列棚が利用可能になります。イベントが有効でない場合、陳列棚は空で返されます。 |
| displayItems | [List<DisplayItemMaster>](#displayitemmaster) | | ✓ | | 1 ~ 1000 items | 陳列する商品リスト
この陳列棚に陳列される商品のリストです。各陳列商品は単一の商品または商品グループのいずれかです。販売期間イベントが終了または無効な商品は、陳列棚の取得時に自動的にフィルタリングされます。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeShowcaseMasters - 陳列棚マスターの一覧を取得
createShowcaseMaster - 陳列棚マスターを新規作成
getShowcaseMaster - 陳列棚マスターを取得
updateShowcaseMaster - 陳列棚マスターを更新
deleteShowcaseMaster - 陳列棚マスターを削除
---
### DisplayItemMaster
陳列する商品のマスターデータ
陳列棚に表示される商品のマスターデータです。名前で単一の商品または商品グループのいずれかを参照できます。各陳列商品には、陳列棚全体の販売期間とは独立して GS2-Schedule イベントによる個別の販売期間を設定できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| displayItemId | string | | ✓ | UUID | ~ 128文字 | 陳列商品ID
陳列商品の一意な名前を保持します。
省略するとシステムによって UUID（Universally Unique Identifier）フォーマットで自動的に割り当てられます。 |
| type | 文字列列挙型
enum {
"salesItem",
"salesItemGroup"
}
| | ✓ | | | 種類
表示する商品の種類です。「salesItem」は固定の対価と報酬を持つ単一商品です。「salesItemGroup」は複数の商品を順番に評価する商品グループで、ステップアップ価格や初回限定割引などに使用されます。"salesItem": 商品 / "salesItemGroup": 商品グループ / |
| salesItemName | string | {type} == "salesItem" | ✓※ | | ~ 128文字 | 商品の名前
表示する商品の名前です。陳列商品の種類が「salesItem」の場合に、商品マスターで定義された特定の商品を参照するために使用されます。
※ type が "salesItem" であれば 必須 |
| salesItemGroupName | string | {type} == "salesItemGroup" | ✓※ | | ~ 128文字 | 商品グループの名前
表示する商品グループの名前です。陳列商品の種類が「salesItemGroup」の場合に、購入回数に基づいて複数の商品を評価する商品グループを参照するために使用されます。
※ type が "salesItemGroup" であれば 必須 |
| salesPeriodEventId | string | | | | ~ 1024文字 | この陳列商品の販売期間を設定した GS2-Schedule のイベントGRN
この個別の陳列商品の販売期間を制御します。指定した場合、関連する GS2-Schedule のイベント期間中のみ陳列棚に表示されます。陳列棚全体の販売期間とは独立して動作します。 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するモデル:**
ShowcaseMaster - 陳列棚マスター
---
### RandomShowcaseMaster
ランダム陳列棚マスター
ランダム陳列棚マスターは、ゲーム内で使用されるランダム陳列棚の編集・管理用データで、マネージメントコンソールのマスターデータエディタで一時的に保持されます。
インポート・更新処理を行うことで、実際にゲームから参照されるランダム陳列棚として反映されます。
ランダム陳列棚は、指定した周期で入れ替わるランダムに選別された商品が陳列される陳列棚のモデルです。
選別される商品は、商品プールに登録された商品から指定数量が、商品ごとに設定された重みに基づいてランダムに選択されます。
ランダム陳列棚には GS2-Schedule のイベントを関連づけることで、販売期間を設定することができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| showcaseId | string | | ※ | | ~ 1024文字 | ランダム陳列棚マスターGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| maximumNumberOfChoice | int | | ✓ | | 1 ~ 100 | 選出される商品の最大数
各ローテーション期間に商品プールからランダムに抽選される商品の数です。重み付きランダム選択で重複なく抽選されるため、1回のローテーションで同じ商品が2回表示されることはありません。 |
| displayItems | [List<RandomDisplayItemModel>](#randomdisplayitemmodel) | | ✓ | | 1 ~ 100 items | 選出対象のランダム陳列商品リスト
商品がランダムに抽選される候補アイテムのプールです。各アイテムには選択確率を決定する重みと、ローテーション全体で表示可能な回数を制限する在庫数があります。 |
| baseTimestamp | long | | ✓ | | | 陳列する商品を再抽選する基準時刻
ローテーション境界の計算に使用される基準タイムスタンプです。この基準時間から一定間隔（resetIntervalHours）ごとに商品の再抽選が行われます。過去の時刻を指定する必要があります。 |
| resetIntervalHours | int | | ✓ | | 1 ~ 168 | 陳列する商品を再抽選する間隔（時）
各商品ローテーション間の時間数です。baseTimestamp を基準として間隔が経過すると、新しい乱数シードで陳列商品が再抽選されます。1〜168時間（1週間）の範囲で設定できます。 |
| salesPeriodEventId | string | | | | ~ 1024文字 | 陳列棚の販売期間を設定した GS2-Schedule のイベントGRN
このランダム陳列棚全体の販売期間を制御します。指定した場合、関連する GS2-Schedule のイベント期間中のみ陳列棚が利用可能になります。 |
| createdAt | long | | ※ | 現在時刻 | | 作成日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| updatedAt | long | | ※ | 現在時刻 | | 最終更新日時
UNIX 時間・ミリ秒
※ サーバーが自動で設定 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | リビジョン |
**関連するメソッド:**
describeRandomShowcaseMasters - ランダム陳列棚マスターの一覧を取得
createRandomShowcaseMaster - ランダム陳列棚マスターを新規作成
getRandomShowcaseMaster - ランダム陳列棚マスターを取得
updateRandomShowcaseMaster - ランダム陳列棚マスターを更新
deleteRandomShowcaseMaster - ランダム陳列棚マスターを削除
---
## メソッド
### 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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DescribeNamespacesRequest;
import io.gs2.showcase.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2Showcase.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.describe_namespaces(
showcase.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('showcase')
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('showcase')
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) | | ✓| | | トランザクション設定
陳列棚操作時のトランザクションの処理方法を制御する設定です。 |
| buyScript | [ScriptSetting](#scriptsetting) | | | | | 購入を実行しようとしたときに実行するスクリプトの設定
Script トリガーリファレンス - [`buy`](../script/#buy) |
| 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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&showcase.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
TransactionSetting: &showcase.TransactionSetting{
EnableAutoRun: pointy.Bool(false),
QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"),
},
BuyScript: nil,
LogSetting: &showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting((new \Gs2\Showcase\Model\TransactionSetting())
->withEnableAutoRun(false)
->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
->withBuyScript(null)
->withLogSetting((new \Gs2\Showcase\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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.CreateNamespaceRequest;
import io.gs2.showcase.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(new io.gs2.showcase.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.withBuyScript(null)
.withLogSetting(new io.gs2.showcase.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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2Showcase.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(new Gs2.Gs2Showcase.Model.TransactionSetting()
.WithEnableAutoRun(false)
.WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.WithBuyScript(null)
.WithLogSetting(new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.createNamespace(
new Gs2Showcase.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(new Gs2Showcase.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.withBuyScript(null)
.withLogSetting(new Gs2Showcase.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.create_namespace(
showcase.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_transaction_setting(
showcase.TransactionSetting()
.with_enable_auto_run(False)
.with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001'))
.with_buy_script(None)
.with_log_setting(
showcase.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('showcase')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
},
buyScript=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('showcase')
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",
},
buyScript=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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetNamespaceStatusRequest;
import io.gs2.showcase.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2Showcase.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_namespace_status(
showcase.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
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('showcase')
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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetNamespaceRequest;
import io.gs2.showcase.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getNamespace(
new Gs2Showcase.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_namespace(
showcase.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
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('showcase')
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) | | ✓| | | トランザクション設定
陳列棚操作時のトランザクションの処理方法を制御する設定です。 |
| buyScript | [ScriptSetting](#scriptsetting) | | | | | 購入を実行しようとしたときに実行するスクリプトの設定
Script トリガーリファレンス - [`buy`](../script/#buy) |
| 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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&showcase.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
TransactionSetting: &showcase.TransactionSetting{
EnableAutoRun: pointy.Bool(false),
QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"),
},
BuyScript: nil,
LogSetting: &showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting((new \Gs2\Showcase\Model\TransactionSetting())
->withEnableAutoRun(false)
->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
->withBuyScript(null)
->withLogSetting((new \Gs2\Showcase\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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.UpdateNamespaceRequest;
import io.gs2.showcase.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(new io.gs2.showcase.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.withBuyScript(null)
.withLogSetting(new io.gs2.showcase.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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2Showcase.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(new Gs2.Gs2Showcase.Model.TransactionSetting()
.WithEnableAutoRun(false)
.WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.WithBuyScript(null)
.WithLogSetting(new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2Showcase.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(new Gs2Showcase.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.withBuyScript(null)
.withLogSetting(new Gs2Showcase.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.update_namespace(
showcase.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_transaction_setting(
showcase.TransactionSetting()
.with_enable_auto_run(False)
.with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002'))
.with_buy_script(None)
.with_log_setting(
showcase.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('showcase')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
},
buyScript=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('showcase')
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",
},
buyScript=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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DeleteNamespaceRequest;
import io.gs2.showcase.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2Showcase.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.delete_namespace(
showcase.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
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('showcase')
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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetServiceVersionRequest;
import io.gs2.showcase.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2Showcase.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_service_version(
showcase.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
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('showcase')
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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DumpUserDataByUserIdRequest;
import io.gs2.showcase.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2Showcase.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.dump_user_data_by_user_id(
showcase.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
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('showcase')
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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.showcase.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2Showcase.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
showcase.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('showcase')
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('showcase')
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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.CleanUserDataByUserIdRequest;
import io.gs2.showcase.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2Showcase.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.clean_user_data_by_user_id(
showcase.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
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('showcase')
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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.showcase.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2Showcase.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
showcase.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
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('showcase')
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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.showcase.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2Showcase.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
showcase.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('showcase')
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('showcase')
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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.ImportUserDataByUserIdRequest;
import io.gs2.showcase.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2Showcase.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.import_user_data_by_user_id(
showcase.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('showcase')
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('showcase')
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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.CheckImportUserDataByUserIdRequest;
import io.gs2.showcase.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2Showcase.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.check_import_user_data_by_user_id(
showcase.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('showcase')
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('showcase')
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;
```
---
### describeShowcases
陳列棚の一覧を取得
現在のユーザーが利用可能なアクティブな陳列棚の一覧を取得します。販売期間イベント設定に基づいて現在アクティブな陳列棚のみが返されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Showcase>](#showcase) | 陳列棚のリスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DescribeShowcases(
&showcase.DescribeShowcasesRequest {
NamespaceName: pointy.String("namespace-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DescribeShowcasesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->describeShowcases(
(new DescribeShowcasesRequest())
->withNamespaceName("namespace-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DescribeShowcasesRequest;
import io.gs2.showcase.result.DescribeShowcasesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DescribeShowcasesResult result = client.describeShowcases(
new DescribeShowcasesRequest()
.withNamespaceName("namespace-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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeShowcases(
new Gs2.Gs2Showcase.Request.DescribeShowcasesRequest()
.WithNamespaceName("namespace-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.describeShowcases(
new Gs2Showcase.DescribeShowcasesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.describe_showcases(
showcase.DescribeShowcasesRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.describe_showcases({
namespaceName="namespace-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('showcase')
api_result_handler = client.describe_showcases_async({
namespaceName="namespace-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;
```
---
### describeShowcasesByUserId
ユーザーIDを指定して陳列棚の一覧を取得
指定されたユーザーが利用可能なアクティブな陳列棚の一覧を取得します。販売期間イベント設定に基づいて現在アクティブな陳列棚のみが返されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<Showcase>](#showcase) | 陳列棚のリスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DescribeShowcasesByUserId(
&showcase.DescribeShowcasesByUserIdRequest {
NamespaceName: pointy.String("namespace-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DescribeShowcasesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->describeShowcasesByUserId(
(new DescribeShowcasesByUserIdRequest())
->withNamespaceName("namespace-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DescribeShowcasesByUserIdRequest;
import io.gs2.showcase.result.DescribeShowcasesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DescribeShowcasesByUserIdResult result = client.describeShowcasesByUserId(
new DescribeShowcasesByUserIdRequest()
.withNamespaceName("namespace-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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeShowcasesByUserId(
new Gs2.Gs2Showcase.Request.DescribeShowcasesByUserIdRequest()
.WithNamespaceName("namespace-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.describeShowcasesByUserId(
new Gs2Showcase.DescribeShowcasesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.describe_showcases_by_user_id(
showcase.DescribeShowcasesByUserIdRequest()
.with_namespace_name('namespace-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('showcase')
api_result = client.describe_showcases_by_user_id({
namespaceName="namespace-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('showcase')
api_result_handler = client.describe_showcases_by_user_id_async({
namespaceName="namespace-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;
```
---
### getShowcase
陳列棚を取得
現在のユーザー向けに陳列商品を含む指定された陳列棚を取得します。販売期間イベント設定に基づいて陳列棚がアクティブである必要があります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | 陳列棚名
陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Showcase](#showcase) | 陳列棚 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetShowcase(
&showcase.GetShowcaseRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetShowcaseRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->getShowcase(
(new GetShowcaseRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetShowcaseRequest;
import io.gs2.showcase.result.GetShowcaseResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
GetShowcaseResult result = client.getShowcase(
new GetShowcaseRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withAccessToken("accessToken-0001")
);
Showcase 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetShowcase(
new Gs2.Gs2Showcase.Request.GetShowcaseRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getShowcase(
new Gs2Showcase.GetShowcaseRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_showcase(
showcase.GetShowcaseRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.get_showcase({
namespaceName="namespace-0001",
showcaseName="showcase-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('showcase')
api_result_handler = client.get_showcase_async({
namespaceName="namespace-0001",
showcaseName="showcase-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;
```
---
### getShowcaseByUserId
ユーザーIDを指定して陳列棚を取得
指定されたユーザー向けに陳列商品を含む指定された陳列棚を取得します。販売期間イベント設定に基づいて陳列棚がアクティブである必要があります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | 陳列棚名
陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [Showcase](#showcase) | 陳列棚 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetShowcaseByUserId(
&showcase.GetShowcaseByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetShowcaseByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->getShowcaseByUserId(
(new GetShowcaseByUserIdRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetShowcaseByUserIdRequest;
import io.gs2.showcase.result.GetShowcaseByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
GetShowcaseByUserIdResult result = client.getShowcaseByUserId(
new GetShowcaseByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
Showcase 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetShowcaseByUserId(
new Gs2.Gs2Showcase.Request.GetShowcaseByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getShowcaseByUserId(
new Gs2Showcase.GetShowcaseByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_showcase_by_user_id(
showcase.GetShowcaseByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-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('showcase')
api_result = client.get_showcase_by_user_id({
namespaceName="namespace-0001",
showcaseName="showcase-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('showcase')
api_result_handler = client.get_showcase_by_user_id_async({
namespaceName="namespace-0001",
showcaseName="showcase-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;
```
---
### buy
商品を購入
指定された陳列棚から陳列商品を購入します。商品に定義された検証、消費、入手アクションを処理するトランザクションが生成されます。設定値を渡してトランザクション変数を上書きすることも可能です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | 陳列棚名
陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| displayItemId | string | | ✓| UUID | ~ 128文字 | 陳列商品ID
陳列商品の一意な名前を保持します。
省略するとシステムによって UUID（Universally Unique Identifier）フォーマットで自動的に割り当てられます。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| quantity | int | | | 1 | 1 ~ 1000 | 購入数量 |
| config | [List<Config>](#config) | | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SalesItem](#salesitem) | 商品 |
| 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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.Buy(
&showcase.BuyRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
DisplayItemId: pointy.String("display-item-0001"),
AccessToken: pointy.String("accessToken-0001"),
Quantity: nil,
Config: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\BuyRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->buy(
(new BuyRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDisplayItemId("display-item-0001")
->withAccessToken("accessToken-0001")
->withQuantity(null)
->withConfig(null)
);
$item = $result->getItem();
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.BuyRequest;
import io.gs2.showcase.result.BuyResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
BuyResult result = client.buy(
new BuyRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemId("display-item-0001")
.withAccessToken("accessToken-0001")
.withQuantity(null)
.withConfig(null)
);
SalesItem item = result.getItem();
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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.Buy(
new Gs2.Gs2Showcase.Request.BuyRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDisplayItemId("display-item-0001")
.WithAccessToken("accessToken-0001")
.WithQuantity(null)
.WithConfig(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.buy(
new Gs2Showcase.BuyRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemId("display-item-0001")
.withAccessToken("accessToken-0001")
.withQuantity(null)
.withConfig(null)
);
const item = result.getItem();
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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.buy(
showcase.BuyRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_display_item_id('display-item-0001')
.with_access_token('accessToken-0001')
.with_quantity(None)
.with_config(None)
)
item = result.item
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('showcase')
api_result = client.buy({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemId="display-item-0001",
accessToken="accessToken-0001",
quantity=nil,
config=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
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('showcase')
api_result_handler = client.buy_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemId="display-item-0001",
accessToken="accessToken-0001",
quantity=nil,
config=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;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### buyByUserId
ユーザーIDを指定して商品を購入
指定されたユーザーに対して指定された陳列棚から陳列商品を購入します。商品に定義された検証、消費、入手アクションを処理するトランザクションが生成されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | 陳列棚名
陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| displayItemId | string | | ✓| UUID | ~ 128文字 | 陳列商品ID
陳列商品の一意な名前を保持します。
省略するとシステムによって UUID（Universally Unique Identifier）フォーマットで自動的に割り当てられます。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| quantity | int | | | 1 | 1 ~ 1000 | 購入数量 |
| config | [List<Config>](#config) | | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SalesItem](#salesitem) | 商品 |
| 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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.BuyByUserId(
&showcase.BuyByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
DisplayItemId: pointy.String("display-item-0001"),
UserId: pointy.String("user-0001"),
Quantity: nil,
Config: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\BuyByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->buyByUserId(
(new BuyByUserIdRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDisplayItemId("display-item-0001")
->withUserId("user-0001")
->withQuantity(null)
->withConfig(null)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.BuyByUserIdRequest;
import io.gs2.showcase.result.BuyByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
BuyByUserIdResult result = client.buyByUserId(
new BuyByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemId("display-item-0001")
.withUserId("user-0001")
.withQuantity(null)
.withConfig(null)
.withTimeOffsetToken(null)
);
SalesItem item = result.getItem();
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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.BuyByUserId(
new Gs2.Gs2Showcase.Request.BuyByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDisplayItemId("display-item-0001")
.WithUserId("user-0001")
.WithQuantity(null)
.WithConfig(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.buyByUserId(
new Gs2Showcase.BuyByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemId("display-item-0001")
.withUserId("user-0001")
.withQuantity(null)
.withConfig(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.buy_by_user_id(
showcase.BuyByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_display_item_id('display-item-0001')
.with_user_id('user-0001')
.with_quantity(None)
.with_config(None)
.with_time_offset_token(None)
)
item = result.item
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('showcase')
api_result = client.buy_by_user_id({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemId="display-item-0001",
userId="user-0001",
quantity=nil,
config=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
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('showcase')
api_result_handler = client.buy_by_user_id_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemId="display-item-0001",
userId="user-0001",
quantity=nil,
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
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### incrementPurchaseCount
購入回数を加算
ランダム陳列棚の特定の商品の購入回数を加算します。ローテーション期間ごとの購入制限を追跡するために使用されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名 |
| displayItemName | string | | ✓| | ~ 128文字 | 商品購入回数名
購入回数を追跡するランダム陳列商品の名前です。ランダム陳列棚内の陳列商品名に対応します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| count | int | | ✓| | 0 ~ 100 | 加算する購入回数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomDisplayItem](#randomdisplayitem) | 購入回数加算後のランダム陳列商品 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.IncrementPurchaseCount(
&showcase.IncrementPurchaseCountRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
DisplayItemName: pointy.String("item-0001"),
AccessToken: pointy.String("accessToken-0001"),
Count: pointy.Int32(1),
}
)
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\IncrementPurchaseCountRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->incrementPurchaseCount(
(new IncrementPurchaseCountRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDisplayItemName("item-0001")
->withAccessToken("accessToken-0001")
->withCount(1)
);
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.IncrementPurchaseCountRequest;
import io.gs2.showcase.result.IncrementPurchaseCountResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
IncrementPurchaseCountResult result = client.incrementPurchaseCount(
new IncrementPurchaseCountRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("item-0001")
.withAccessToken("accessToken-0001")
.withCount(1)
);
RandomDisplayItem 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.IncrementPurchaseCount(
new Gs2.Gs2Showcase.Request.IncrementPurchaseCountRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDisplayItemName("item-0001")
.WithAccessToken("accessToken-0001")
.WithCount(1),
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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.incrementPurchaseCount(
new Gs2Showcase.IncrementPurchaseCountRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("item-0001")
.withAccessToken("accessToken-0001")
.withCount(1)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.increment_purchase_count(
showcase.IncrementPurchaseCountRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_display_item_name('item-0001')
.with_access_token('accessToken-0001')
.with_count(1)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.increment_purchase_count({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="item-0001",
accessToken="accessToken-0001",
count=1,
})
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('showcase')
api_result_handler = client.increment_purchase_count_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="item-0001",
accessToken="accessToken-0001",
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
item = result.item;
```
---
### incrementPurchaseCountByUserId
ユーザーIDを指定して購入回数を加算
指定されたユーザーのランダム陳列棚の特定の商品の購入回数を加算します。ローテーション期間ごとの購入制限を追跡するために使用されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名 |
| displayItemName | string | | ✓| | ~ 128文字 | 商品購入回数名
購入回数を追跡するランダム陳列商品の名前です。ランダム陳列棚内の陳列商品名に対応します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| count | int | | ✓| | 0 ~ 100 | 加算する購入回数 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomDisplayItem](#randomdisplayitem) | 購入回数加算後のランダム陳列商品 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.IncrementPurchaseCountByUserId(
&showcase.IncrementPurchaseCountByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
DisplayItemName: pointy.String("item-0001"),
UserId: pointy.String("user-0001"),
Count: pointy.Int32(1),
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\IncrementPurchaseCountByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->incrementPurchaseCountByUserId(
(new IncrementPurchaseCountByUserIdRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDisplayItemName("item-0001")
->withUserId("user-0001")
->withCount(1)
->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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.IncrementPurchaseCountByUserIdRequest;
import io.gs2.showcase.result.IncrementPurchaseCountByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
IncrementPurchaseCountByUserIdResult result = client.incrementPurchaseCountByUserId(
new IncrementPurchaseCountByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("item-0001")
.withUserId("user-0001")
.withCount(1)
.withTimeOffsetToken(null)
);
RandomDisplayItem 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.IncrementPurchaseCountByUserId(
new Gs2.Gs2Showcase.Request.IncrementPurchaseCountByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDisplayItemName("item-0001")
.WithUserId("user-0001")
.WithCount(1)
.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.incrementPurchaseCountByUserId(
new Gs2Showcase.IncrementPurchaseCountByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("item-0001")
.withUserId("user-0001")
.withCount(1)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.increment_purchase_count_by_user_id(
showcase.IncrementPurchaseCountByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_display_item_name('item-0001')
.with_user_id('user-0001')
.with_count(1)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.increment_purchase_count_by_user_id({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="item-0001",
userId="user-0001",
count=1,
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('showcase')
api_result_handler = client.increment_purchase_count_by_user_id_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="item-0001",
userId="user-0001",
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
item = result.item;
```
---
### decrementPurchaseCountByUserId
ユーザーIDを指定して購入回数を減算
ランダム陳列棚の特定の商品の購入回数を減算します。購入の取り消しや購入カウンターの調整に使用されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名 |
| displayItemName | string | | ✓| | ~ 128文字 | 商品購入回数名
購入回数を追跡するランダム陳列商品の名前です。ランダム陳列棚内の陳列商品名に対応します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| count | int | | ✓| | 0 ~ 100 | 減算する購入回数 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomDisplayItem](#randomdisplayitem) | 購入回数減算後のランダム陳列商品 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DecrementPurchaseCountByUserId(
&showcase.DecrementPurchaseCountByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
DisplayItemName: pointy.String("item-0001"),
UserId: pointy.String("user-0001"),
Count: pointy.Int32(1),
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DecrementPurchaseCountByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->decrementPurchaseCountByUserId(
(new DecrementPurchaseCountByUserIdRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDisplayItemName("item-0001")
->withUserId("user-0001")
->withCount(1)
->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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DecrementPurchaseCountByUserIdRequest;
import io.gs2.showcase.result.DecrementPurchaseCountByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DecrementPurchaseCountByUserIdResult result = client.decrementPurchaseCountByUserId(
new DecrementPurchaseCountByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("item-0001")
.withUserId("user-0001")
.withCount(1)
.withTimeOffsetToken(null)
);
RandomDisplayItem 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DecrementPurchaseCountByUserId(
new Gs2.Gs2Showcase.Request.DecrementPurchaseCountByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDisplayItemName("item-0001")
.WithUserId("user-0001")
.WithCount(1)
.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.decrementPurchaseCountByUserId(
new Gs2Showcase.DecrementPurchaseCountByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("item-0001")
.withUserId("user-0001")
.withCount(1)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.decrement_purchase_count_by_user_id(
showcase.DecrementPurchaseCountByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_display_item_name('item-0001')
.with_user_id('user-0001')
.with_count(1)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.decrement_purchase_count_by_user_id({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="item-0001",
userId="user-0001",
count=1,
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('showcase')
api_result_handler = client.decrement_purchase_count_by_user_id_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="item-0001",
userId="user-0001",
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
item = result.item;
```
---
### forceReDrawByUserId
ユーザーIDを指定してランダム陳列棚の内容を再抽選
指定されたユーザーのランダム陳列棚の商品を強制的に再抽選し、現在の選択をリセットして設定されたプールから新しいランダム商品の選択をトリガーします。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<RandomDisplayItem>](#randomdisplayitem) | ランダム陳列棚の商品一覧 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.ForceReDrawByUserId(
&showcase.ForceReDrawByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\ForceReDrawByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->forceReDrawByUserId(
(new ForceReDrawByUserIdRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.ForceReDrawByUserIdRequest;
import io.gs2.showcase.result.ForceReDrawByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
ForceReDrawByUserIdResult result = client.forceReDrawByUserId(
new ForceReDrawByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.ForceReDrawByUserId(
new Gs2.Gs2Showcase.Request.ForceReDrawByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.forceReDrawByUserId(
new Gs2Showcase.ForceReDrawByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.force_re_draw_by_user_id(
showcase.ForceReDrawByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-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('showcase')
api_result = client.force_re_draw_by_user_id({
namespaceName="namespace-0001",
showcaseName="showcase-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('showcase')
api_result_handler = client.force_re_draw_by_user_id_async({
namespaceName="namespace-0001",
showcaseName="showcase-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;
```
---
### describeRandomDisplayItems
ランダム陳列棚の商品一覧を取得
現在のユーザーに対してランダム陳列棚に現在表示されている商品の一覧を取得します。商品は設定されたプールからランダムに選択され、リセット間隔に基づいてローテーションされます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<RandomDisplayItem>](#randomdisplayitem) | ランダム陳列棚の商品リスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DescribeRandomDisplayItems(
&showcase.DescribeRandomDisplayItemsRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DescribeRandomDisplayItemsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->describeRandomDisplayItems(
(new DescribeRandomDisplayItemsRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DescribeRandomDisplayItemsRequest;
import io.gs2.showcase.result.DescribeRandomDisplayItemsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DescribeRandomDisplayItemsResult result = client.describeRandomDisplayItems(
new DescribeRandomDisplayItemsRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeRandomDisplayItems(
new Gs2.Gs2Showcase.Request.DescribeRandomDisplayItemsRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.describeRandomDisplayItems(
new Gs2Showcase.DescribeRandomDisplayItemsRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withAccessToken("accessToken-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.describe_random_display_items(
showcase.DescribeRandomDisplayItemsRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_access_token('accessToken-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.describe_random_display_items({
namespaceName="namespace-0001",
showcaseName="showcase-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('showcase')
api_result_handler = client.describe_random_display_items_async({
namespaceName="namespace-0001",
showcaseName="showcase-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;
```
---
### describeRandomDisplayItemsByUserId
ユーザーIDを指定してランダム陳列棚の商品一覧を取得
指定されたユーザーに対してランダム陳列棚に現在表示されている商品の一覧を取得します。商品は設定されたプールからランダムに選択され、リセット間隔に基づいてローテーションされます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<RandomDisplayItem>](#randomdisplayitem) | ランダム陳列棚の商品リスト |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DescribeRandomDisplayItemsByUserId(
&showcase.DescribeRandomDisplayItemsByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DescribeRandomDisplayItemsByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->describeRandomDisplayItemsByUserId(
(new DescribeRandomDisplayItemsByUserIdRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DescribeRandomDisplayItemsByUserIdRequest;
import io.gs2.showcase.result.DescribeRandomDisplayItemsByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DescribeRandomDisplayItemsByUserIdResult result = client.describeRandomDisplayItemsByUserId(
new DescribeRandomDisplayItemsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeRandomDisplayItemsByUserId(
new Gs2.Gs2Showcase.Request.DescribeRandomDisplayItemsByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.describeRandomDisplayItemsByUserId(
new Gs2Showcase.DescribeRandomDisplayItemsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.describe_random_display_items_by_user_id(
showcase.DescribeRandomDisplayItemsByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-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('showcase')
api_result = client.describe_random_display_items_by_user_id({
namespaceName="namespace-0001",
showcaseName="showcase-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('showcase')
api_result_handler = client.describe_random_display_items_by_user_id_async({
namespaceName="namespace-0001",
showcaseName="showcase-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;
```
---
### getRandomDisplayItem
ランダム陳列棚の商品を取得
現在のユーザーに対してランダム陳列棚から指定された商品を取得します。販売期間イベントに基づいてランダム陳列棚が利用可能である必要があります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| displayItemName | string | | ✓| UUID | ~ 128文字 | ランダム陳列商品名
ランダム陳列商品の一意な名前を保持します。
省略するとシステムによって UUID（Universally Unique Identifier）フォーマットで自動的に割り当てられます。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomDisplayItem](#randomdisplayitem) | 商品 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetRandomDisplayItem(
&showcase.GetRandomDisplayItemRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
DisplayItemName: pointy.String("display-item-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetRandomDisplayItemRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->getRandomDisplayItem(
(new GetRandomDisplayItemRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDisplayItemName("display-item-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetRandomDisplayItemRequest;
import io.gs2.showcase.result.GetRandomDisplayItemResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
GetRandomDisplayItemResult result = client.getRandomDisplayItem(
new GetRandomDisplayItemRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("display-item-0001")
.withAccessToken("accessToken-0001")
);
RandomDisplayItem 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetRandomDisplayItem(
new Gs2.Gs2Showcase.Request.GetRandomDisplayItemRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDisplayItemName("display-item-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getRandomDisplayItem(
new Gs2Showcase.GetRandomDisplayItemRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("display-item-0001")
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_random_display_item(
showcase.GetRandomDisplayItemRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_display_item_name('display-item-0001')
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.get_random_display_item({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="display-item-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('showcase')
api_result_handler = client.get_random_display_item_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="display-item-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;
```
---
### getRandomDisplayItemByUserId
ユーザーIDを指定してランダム陳列棚の商品を取得
指定されたユーザーに対してランダム陳列棚から指定された商品を取得します。販売期間イベントに基づいてランダム陳列棚が利用可能である必要があります。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| displayItemName | string | | ✓| UUID | ~ 128文字 | ランダム陳列商品名
ランダム陳列商品の一意な名前を保持します。
省略するとシステムによって UUID（Universally Unique Identifier）フォーマットで自動的に割り当てられます。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomDisplayItem](#randomdisplayitem) | 商品 |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetRandomDisplayItemByUserId(
&showcase.GetRandomDisplayItemByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
DisplayItemName: pointy.String("display-item-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetRandomDisplayItemByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->getRandomDisplayItemByUserId(
(new GetRandomDisplayItemByUserIdRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDisplayItemName("display-item-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetRandomDisplayItemByUserIdRequest;
import io.gs2.showcase.result.GetRandomDisplayItemByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
GetRandomDisplayItemByUserIdResult result = client.getRandomDisplayItemByUserId(
new GetRandomDisplayItemByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("display-item-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
RandomDisplayItem 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetRandomDisplayItemByUserId(
new Gs2.Gs2Showcase.Request.GetRandomDisplayItemByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDisplayItemName("display-item-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getRandomDisplayItemByUserId(
new Gs2Showcase.GetRandomDisplayItemByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("display-item-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_random_display_item_by_user_id(
showcase.GetRandomDisplayItemByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_display_item_name('display-item-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('showcase')
api_result = client.get_random_display_item_by_user_id({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="display-item-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('showcase')
api_result_handler = client.get_random_display_item_by_user_id_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="display-item-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;
```
---
### randomShowcaseBuy
ランダム陳列棚の商品を購入
ランダム陳列棚から商品を購入します。設定された検証、消費、入手アクションを処理するトランザクションが生成されます。設定値を渡してトランザクション変数を上書きすることも可能です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| displayItemName | string | | ✓| UUID | ~ 128文字 | ランダム陳列商品名
ランダム陳列商品の一意な名前を保持します。
省略するとシステムによって UUID（Universally Unique Identifier）フォーマットで自動的に割り当てられます。 |
| accessToken | string | | ✓| | ~ 128文字 | アクセストークン |
| quantity | int | | | 1 | 1 ~ 1000 | 購入数量 |
| config | [List<Config>](#config) | | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomDisplayItem](#randomdisplayitem) | 購入した商品 |
| 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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.RandomShowcaseBuy(
&showcase.RandomShowcaseBuyRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
DisplayItemName: pointy.String("display-item-0001"),
AccessToken: pointy.String("accessToken-0001"),
Quantity: pointy.Int32(1),
Config: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\RandomShowcaseBuyRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->randomShowcaseBuy(
(new RandomShowcaseBuyRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDisplayItemName("display-item-0001")
->withAccessToken("accessToken-0001")
->withQuantity(1)
->withConfig(null)
);
$item = $result->getItem();
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.RandomShowcaseBuyRequest;
import io.gs2.showcase.result.RandomShowcaseBuyResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
RandomShowcaseBuyResult result = client.randomShowcaseBuy(
new RandomShowcaseBuyRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("display-item-0001")
.withAccessToken("accessToken-0001")
.withQuantity(1)
.withConfig(null)
);
RandomDisplayItem item = result.getItem();
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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.RandomShowcaseBuy(
new Gs2.Gs2Showcase.Request.RandomShowcaseBuyRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDisplayItemName("display-item-0001")
.WithAccessToken("accessToken-0001")
.WithQuantity(1)
.WithConfig(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.randomShowcaseBuy(
new Gs2Showcase.RandomShowcaseBuyRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("display-item-0001")
.withAccessToken("accessToken-0001")
.withQuantity(1)
.withConfig(null)
);
const item = result.getItem();
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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.random_showcase_buy(
showcase.RandomShowcaseBuyRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_display_item_name('display-item-0001')
.with_access_token('accessToken-0001')
.with_quantity(1)
.with_config(None)
)
item = result.item
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('showcase')
api_result = client.random_showcase_buy({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="display-item-0001",
accessToken="accessToken-0001",
quantity=1,
config=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
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('showcase')
api_result_handler = client.random_showcase_buy_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="display-item-0001",
accessToken="accessToken-0001",
quantity=1,
config=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;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### randomShowcaseBuyByUserId
ユーザーIDを指定してランダム陳列棚の商品を購入
指定されたユーザーに対してランダム陳列棚から商品を購入します。設定された検証、消費、入手アクションを処理するトランザクションが生成されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| displayItemName | string | | ✓| UUID | ~ 128文字 | ランダム陳列商品名
ランダム陳列商品の一意な名前を保持します。
省略するとシステムによって UUID（Universally Unique Identifier）フォーマットで自動的に割り当てられます。 |
| userId | string | | ✓| | ~ 128文字 | ユーザーID |
| quantity | int | | | 1 | 1 ~ 1000 | 購入数量 |
| config | [List<Config>](#config) | | | [] | 0 ~ 32 items | トランザクションの変数に適用する設定値 |
| timeOffsetToken | string | | | | ~ 1024文字 | タイムオフセットトークン |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomDisplayItem](#randomdisplayitem) | 購入した商品 |
| 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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.RandomShowcaseBuyByUserId(
&showcase.RandomShowcaseBuyByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
DisplayItemName: pointy.String("display-item-0001"),
UserId: pointy.String("user-0001"),
Quantity: pointy.Int32(1),
Config: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\RandomShowcaseBuyByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->randomShowcaseBuyByUserId(
(new RandomShowcaseBuyByUserIdRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDisplayItemName("display-item-0001")
->withUserId("user-0001")
->withQuantity(1)
->withConfig(null)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.RandomShowcaseBuyByUserIdRequest;
import io.gs2.showcase.result.RandomShowcaseBuyByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
RandomShowcaseBuyByUserIdResult result = client.randomShowcaseBuyByUserId(
new RandomShowcaseBuyByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("display-item-0001")
.withUserId("user-0001")
.withQuantity(1)
.withConfig(null)
.withTimeOffsetToken(null)
);
RandomDisplayItem item = result.getItem();
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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.RandomShowcaseBuyByUserId(
new Gs2.Gs2Showcase.Request.RandomShowcaseBuyByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDisplayItemName("display-item-0001")
.WithUserId("user-0001")
.WithQuantity(1)
.WithConfig(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.randomShowcaseBuyByUserId(
new Gs2Showcase.RandomShowcaseBuyByUserIdRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDisplayItemName("display-item-0001")
.withUserId("user-0001")
.withQuantity(1)
.withConfig(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.random_showcase_buy_by_user_id(
showcase.RandomShowcaseBuyByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_display_item_name('display-item-0001')
.with_user_id('user-0001')
.with_quantity(1)
.with_config(None)
.with_time_offset_token(None)
)
item = result.item
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('showcase')
api_result = client.random_showcase_buy_by_user_id({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="display-item-0001",
userId="user-0001",
quantity=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
item = result.item;
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('showcase')
api_result_handler = client.random_showcase_buy_by_user_id_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
displayItemName="display-item-0001",
userId="user-0001",
quantity=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
item = result.item;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### exportMaster
陳列棚マスターを有効化可能なマスターデータ形式でエクスポート
現在登録されている陳列棚マスターを有効化可能なマスターデータ形式でエクスポートします。エクスポートされたデータには、陳列棚、商品、商品グループ、ランダム陳列棚のすべての定義が含まれます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentShowcaseMaster](#currentshowcasemaster) | 有効化可能な陳列棚のマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.ExportMaster(
&showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\ExportMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.ExportMasterRequest;
import io.gs2.showcase.result.ExportMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
ExportMasterResult result = client.exportMaster(
new ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExportMaster(
new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.exportMaster(
new Gs2Showcase.ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.export_master(
showcase.ExportMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
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('showcase')
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;
```
---
### getCurrentShowcaseMaster
現在アクティブな陳列棚のマスターデータを取得
使用中のすべての陳列棚、商品、商品グループ、ランダム陳列棚の定義を含む、現在アクティブな陳列棚マスターデータを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentShowcaseMaster](#currentshowcasemaster) | 現在アクティブな陳列棚のマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetCurrentShowcaseMaster(
&showcase.GetCurrentShowcaseMasterRequest {
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetCurrentShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->getCurrentShowcaseMaster(
(new GetCurrentShowcaseMasterRequest())
->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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetCurrentShowcaseMasterRequest;
import io.gs2.showcase.result.GetCurrentShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
GetCurrentShowcaseMasterResult result = client.getCurrentShowcaseMaster(
new GetCurrentShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCurrentShowcaseMaster(
new Gs2.Gs2Showcase.Request.GetCurrentShowcaseMasterRequest()
.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getCurrentShowcaseMaster(
new Gs2Showcase.GetCurrentShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_current_showcase_master(
showcase.GetCurrentShowcaseMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.get_current_showcase_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('showcase')
api_result_handler = client.get_current_showcase_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;
```
---
### preUpdateCurrentShowcaseMaster
現在アクティブな陳列棚のマスターデータを更新（3フェーズ版）
1MBを超えるマスターデータをアップロードする場合は、3フェーズで更新を行います。
1. このAPIを実行し、アップロード用のトークンとURLを取得します。
2. 取得したURLに対して、マスターデータをアップロードします。
3. UpdateCurrentShowcaseMaster にアップロードで取得したトークンを渡して実行し、マスターデータを反映します。
#### 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/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.PreUpdateCurrentShowcaseMaster(
&showcase.PreUpdateCurrentShowcaseMasterRequest {
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\PreUpdateCurrentShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->preUpdateCurrentShowcaseMaster(
(new PreUpdateCurrentShowcaseMasterRequest())
->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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.PreUpdateCurrentShowcaseMasterRequest;
import io.gs2.showcase.result.PreUpdateCurrentShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
PreUpdateCurrentShowcaseMasterResult result = client.preUpdateCurrentShowcaseMaster(
new PreUpdateCurrentShowcaseMasterRequest()
.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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.PreUpdateCurrentShowcaseMaster(
new Gs2.Gs2Showcase.Request.PreUpdateCurrentShowcaseMasterRequest()
.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.preUpdateCurrentShowcaseMaster(
new Gs2Showcase.PreUpdateCurrentShowcaseMasterRequest()
.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.pre_update_current_showcase_master(
showcase.PreUpdateCurrentShowcaseMasterRequest()
.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('showcase')
api_result = client.pre_update_current_showcase_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('showcase')
api_result_handler = client.pre_update_current_showcase_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;
```
---
### updateCurrentShowcaseMaster
現在アクティブな陳列棚のマスターデータを更新
現在アクティブな陳列棚マスターデータを更新します。大容量マスターデータに対応するため、直接更新モードと事前アップロードモードの両方をサポートしています。事前アップロードモードでは、PreUpdate APIで取得したアップロードトークンを使用して設定を読み取ります。
#### 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 | [CurrentShowcaseMaster](#currentshowcasemaster) | 更新された現在アクティブな陳列棚のマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.UpdateCurrentShowcaseMaster(
&showcase.UpdateCurrentShowcaseMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Mode: pointy.String("direct"),
Settings: pointy.String("{\n \"version\": \"2019-04-04\",\n \"showcases\": [\n {\n \"name\": \"gem\",\n \"metadata\": \"GEM\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"gem_3000\",\n \"metadata\": \"GEM_3000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItemGroup\",\n \"salesPeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001\",\n \"salesItemGroup\": {\n \"name\": \"step_gem\",\n \"metadata\": \"STEP_GEM\",\n \"salesItems\": [\n {\n \"name\": \"step1_gem_1000\",\n \"metadata\": \"STEP1_GEM_1000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n },\n {\n \"name\": \"step2_gem_2000\",\n \"metadata\": \"STEP1_GEM_2000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n ]\n }\n }\n ]\n },\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"single\",\n \"metadata\": \"SINGLE\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"{\\\"moneyName\\\": \\\"money-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"slot\\\": \\\"{slot}\\\", \\\"count\\\": 100, \\\"paidOnly\\\": false}\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"{\\\"categoryName\\\": \\\"category-0001\\\", \\\"inventoryModelName\\\": \\\"character\\\", \\\"itemModelName\\\": \\\"ssr-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"acquireCount\\\": 1}\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"10times\",\n \"metadata\": \"10TIMES\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"Gs2Money:WithdrawByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n }\n ]\n }\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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\UpdateCurrentShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->updateCurrentShowcaseMaster(
(new UpdateCurrentShowcaseMasterRequest())
->withNamespaceName("namespace-0001")
->withMode("direct")
->withSettings("{\n \"version\": \"2019-04-04\",\n \"showcases\": [\n {\n \"name\": \"gem\",\n \"metadata\": \"GEM\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"gem_3000\",\n \"metadata\": \"GEM_3000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItemGroup\",\n \"salesPeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001\",\n \"salesItemGroup\": {\n \"name\": \"step_gem\",\n \"metadata\": \"STEP_GEM\",\n \"salesItems\": [\n {\n \"name\": \"step1_gem_1000\",\n \"metadata\": \"STEP1_GEM_1000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n },\n {\n \"name\": \"step2_gem_2000\",\n \"metadata\": \"STEP1_GEM_2000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n ]\n }\n }\n ]\n },\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"single\",\n \"metadata\": \"SINGLE\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"{\\\"moneyName\\\": \\\"money-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"slot\\\": \\\"{slot}\\\", \\\"count\\\": 100, \\\"paidOnly\\\": false}\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"{\\\"categoryName\\\": \\\"category-0001\\\", \\\"inventoryModelName\\\": \\\"character\\\", \\\"itemModelName\\\": \\\"ssr-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"acquireCount\\\": 1}\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"10times\",\n \"metadata\": \"10TIMES\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"Gs2Money:WithdrawByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n }\n ]\n }\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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.UpdateCurrentShowcaseMasterRequest;
import io.gs2.showcase.result.UpdateCurrentShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
UpdateCurrentShowcaseMasterResult result = client.updateCurrentShowcaseMaster(
new UpdateCurrentShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\n \"version\": \"2019-04-04\",\n \"showcases\": [\n {\n \"name\": \"gem\",\n \"metadata\": \"GEM\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"gem_3000\",\n \"metadata\": \"GEM_3000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItemGroup\",\n \"salesPeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001\",\n \"salesItemGroup\": {\n \"name\": \"step_gem\",\n \"metadata\": \"STEP_GEM\",\n \"salesItems\": [\n {\n \"name\": \"step1_gem_1000\",\n \"metadata\": \"STEP1_GEM_1000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n },\n {\n \"name\": \"step2_gem_2000\",\n \"metadata\": \"STEP1_GEM_2000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n ]\n }\n }\n ]\n },\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"single\",\n \"metadata\": \"SINGLE\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"{\\\"moneyName\\\": \\\"money-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"slot\\\": \\\"{slot}\\\", \\\"count\\\": 100, \\\"paidOnly\\\": false}\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"{\\\"categoryName\\\": \\\"category-0001\\\", \\\"inventoryModelName\\\": \\\"character\\\", \\\"itemModelName\\\": \\\"ssr-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"acquireCount\\\": 1}\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"10times\",\n \"metadata\": \"10TIMES\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"Gs2Money:WithdrawByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n }\n ]\n }\n }\n ]\n }\n ]\n }")
.withUploadToken(null)
);
CurrentShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentShowcaseMaster(
new Gs2.Gs2Showcase.Request.UpdateCurrentShowcaseMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMode("direct")
.WithSettings("{\n \"version\": \"2019-04-04\",\n \"showcases\": [\n {\n \"name\": \"gem\",\n \"metadata\": \"GEM\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"gem_3000\",\n \"metadata\": \"GEM_3000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItemGroup\",\n \"salesPeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001\",\n \"salesItemGroup\": {\n \"name\": \"step_gem\",\n \"metadata\": \"STEP_GEM\",\n \"salesItems\": [\n {\n \"name\": \"step1_gem_1000\",\n \"metadata\": \"STEP1_GEM_1000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n },\n {\n \"name\": \"step2_gem_2000\",\n \"metadata\": \"STEP1_GEM_2000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n ]\n }\n }\n ]\n },\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"single\",\n \"metadata\": \"SINGLE\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"{\\\"moneyName\\\": \\\"money-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"slot\\\": \\\"{slot}\\\", \\\"count\\\": 100, \\\"paidOnly\\\": false}\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"{\\\"categoryName\\\": \\\"category-0001\\\", \\\"inventoryModelName\\\": \\\"character\\\", \\\"itemModelName\\\": \\\"ssr-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"acquireCount\\\": 1}\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"10times\",\n \"metadata\": \"10TIMES\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"Gs2Money:WithdrawByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n }\n ]\n }\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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.updateCurrentShowcaseMaster(
new Gs2Showcase.UpdateCurrentShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\n \"version\": \"2019-04-04\",\n \"showcases\": [\n {\n \"name\": \"gem\",\n \"metadata\": \"GEM\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"gem_3000\",\n \"metadata\": \"GEM_3000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItemGroup\",\n \"salesPeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001\",\n \"salesItemGroup\": {\n \"name\": \"step_gem\",\n \"metadata\": \"STEP_GEM\",\n \"salesItems\": [\n {\n \"name\": \"step1_gem_1000\",\n \"metadata\": \"STEP1_GEM_1000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n },\n {\n \"name\": \"step2_gem_2000\",\n \"metadata\": \"STEP1_GEM_2000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n ]\n }\n }\n ]\n },\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"single\",\n \"metadata\": \"SINGLE\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"{\\\"moneyName\\\": \\\"money-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"slot\\\": \\\"{slot}\\\", \\\"count\\\": 100, \\\"paidOnly\\\": false}\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"{\\\"categoryName\\\": \\\"category-0001\\\", \\\"inventoryModelName\\\": \\\"character\\\", \\\"itemModelName\\\": \\\"ssr-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"acquireCount\\\": 1}\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"10times\",\n \"metadata\": \"10TIMES\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"Gs2Money:WithdrawByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n }\n ]\n }\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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.update_current_showcase_master(
showcase.UpdateCurrentShowcaseMasterRequest()
.with_namespace_name('namespace-0001')
.with_mode('direct')
.with_settings('{\n "version": "2019-04-04",\n "showcases": [\n {\n "name": "gem",\n "metadata": "GEM",\n "displayItems": [\n {\n "type": "salesItem",\n "salesItem": {\n "name": "gem_3000",\n "metadata": "GEM_3000",\n "consumeActions": [\n {\n "action": "Gs2Money:RecordReceipt",\n "request": "Gs2Money:RecordReceipt:request"\n }\n ],\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "Gs2Money:DepositByUserId:request"\n }\n ]\n }\n },\n {\n "type": "salesItemGroup",\n "salesPeriodEventId": "grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001",\n "salesItemGroup": {\n "name": "step_gem",\n "metadata": "STEP_GEM",\n "salesItems": [\n {\n "name": "step1_gem_1000",\n "metadata": "STEP1_GEM_1000",\n "consumeActions": [\n {\n "action": "Gs2Money:RecordReceipt",\n "request": "Gs2Money:RecordReceipt:request"\n },\n {\n "action": "Gs2Limit:CountUpByUserId",\n "request": "Gs2Limit:CountUpByUserId:request"\n }\n ],\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "Gs2Money:DepositByUserId:request"\n }\n ]\n },\n {\n "name": "step2_gem_2000",\n "metadata": "STEP1_GEM_2000",\n "consumeActions": [\n {\n "action": "Gs2Money:RecordReceipt",\n "request": "Gs2Money:RecordReceipt:request"\n },\n {\n "action": "Gs2Limit:CountUpByUserId",\n "request": "Gs2Limit:CountUpByUserId:request"\n }\n ],\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "Gs2Money:DepositByUserId:request"\n }\n ]\n }\n ]\n }\n }\n ]\n },\n {\n "name": "gacha",\n "metadata": "GACHA",\n "displayItems": [\n {\n "type": "salesItem",\n "salesItem": {\n "name": "single",\n "metadata": "SINGLE",\n "consumeActions": [\n {\n "action": "Gs2Money:WithdrawByUserId",\n "request": "{\\"moneyName\\": \\"money-0001\\", \\"userId\\": \\"{userId}\\", \\"slot\\": \\"{slot}\\", \\"count\\": 100, \\"paidOnly\\": false}"\n }\n ],\n "acquireActions": [\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "{\\"categoryName\\": \\"category-0001\\", \\"inventoryModelName\\": \\"character\\", \\"itemModelName\\": \\"ssr-0001\\", \\"userId\\": \\"{userId}\\", \\"acquireCount\\": 1}"\n }\n ]\n }\n },\n {\n "type": "salesItem",\n "salesItem": {\n "name": "10times",\n "metadata": "10TIMES",\n "consumeActions": [\n {\n "action": "Gs2Money:WithdrawByUserId",\n "request": "Gs2Money:WithdrawByUserId:request"\n }\n ],\n "acquireActions": [\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "Gs2Inventory:AcquireItemSetByUserId:request"\n },\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "Gs2Inventory:AcquireItemSetByUserId:request"\n },\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "Gs2Inventory:AcquireItemSetByUserId:request"\n },\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "Gs2Inventory:AcquireItemSetByUserId:request"\n },\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "Gs2Inventory:AcquireItemSetByUserId:request"\n },\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "Gs2Inventory:AcquireItemSetByUserId:request"\n },\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "Gs2Inventory:AcquireItemSetByUserId:request"\n },\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "Gs2Inventory:AcquireItemSetByUserId:request"\n },\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "Gs2Inventory:AcquireItemSetByUserId:request"\n },\n {\n "action": "Gs2Inventory:AcquireItemSetByUserId",\n "request": "Gs2Inventory:AcquireItemSetByUserId:request"\n }\n ]\n }\n }\n ]\n }\n ]\n }')
.with_upload_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.update_current_showcase_master({
namespaceName="namespace-0001",
mode="direct",
settings="{\n \"version\": \"2019-04-04\",\n \"showcases\": [\n {\n \"name\": \"gem\",\n \"metadata\": \"GEM\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"gem_3000\",\n \"metadata\": \"GEM_3000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItemGroup\",\n \"salesPeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001\",\n \"salesItemGroup\": {\n \"name\": \"step_gem\",\n \"metadata\": \"STEP_GEM\",\n \"salesItems\": [\n {\n \"name\": \"step1_gem_1000\",\n \"metadata\": \"STEP1_GEM_1000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n },\n {\n \"name\": \"step2_gem_2000\",\n \"metadata\": \"STEP1_GEM_2000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n ]\n }\n }\n ]\n },\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"single\",\n \"metadata\": \"SINGLE\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"{\\\"moneyName\\\": \\\"money-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"slot\\\": \\\"{slot}\\\", \\\"count\\\": 100, \\\"paidOnly\\\": false}\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"{\\\"categoryName\\\": \\\"category-0001\\\", \\\"inventoryModelName\\\": \\\"character\\\", \\\"itemModelName\\\": \\\"ssr-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"acquireCount\\\": 1}\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"10times\",\n \"metadata\": \"10TIMES\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"Gs2Money:WithdrawByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n }\n ]\n }\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('showcase')
api_result_handler = client.update_current_showcase_master_async({
namespaceName="namespace-0001",
mode="direct",
settings="{\n \"version\": \"2019-04-04\",\n \"showcases\": [\n {\n \"name\": \"gem\",\n \"metadata\": \"GEM\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"gem_3000\",\n \"metadata\": \"GEM_3000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItemGroup\",\n \"salesPeriodEventId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001\",\n \"salesItemGroup\": {\n \"name\": \"step_gem\",\n \"metadata\": \"STEP_GEM\",\n \"salesItems\": [\n {\n \"name\": \"step1_gem_1000\",\n \"metadata\": \"STEP1_GEM_1000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n },\n {\n \"name\": \"step2_gem_2000\",\n \"metadata\": \"STEP1_GEM_2000\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:RecordReceipt\",\n \"request\": \"Gs2Money:RecordReceipt:request\"\n },\n {\n \"action\": \"Gs2Limit:CountUpByUserId\",\n \"request\": \"Gs2Limit:CountUpByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"Gs2Money:DepositByUserId:request\"\n }\n ]\n }\n ]\n }\n }\n ]\n },\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"displayItems\": [\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"single\",\n \"metadata\": \"SINGLE\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"{\\\"moneyName\\\": \\\"money-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"slot\\\": \\\"{slot}\\\", \\\"count\\\": 100, \\\"paidOnly\\\": false}\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"{\\\"categoryName\\\": \\\"category-0001\\\", \\\"inventoryModelName\\\": \\\"character\\\", \\\"itemModelName\\\": \\\"ssr-0001\\\", \\\"userId\\\": \\\"{userId}\\\", \\\"acquireCount\\\": 1}\"\n }\n ]\n }\n },\n {\n \"type\": \"salesItem\",\n \"salesItem\": {\n \"name\": \"10times\",\n \"metadata\": \"10TIMES\",\n \"consumeActions\": [\n {\n \"action\": \"Gs2Money:WithdrawByUserId\",\n \"request\": \"Gs2Money:WithdrawByUserId:request\"\n }\n ],\n \"acquireActions\": [\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n },\n {\n \"action\": \"Gs2Inventory:AcquireItemSetByUserId\",\n \"request\": \"Gs2Inventory:AcquireItemSetByUserId:request\"\n }\n ]\n }\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;
```
---
### updateCurrentShowcaseMasterFromGitHub
現在アクティブな陳列棚のマスターデータをGitHubから更新
指定されたチェックアウト設定を使用してGitHubリポジトリからマスターデータをチェックアウトし、現在アクティブな陳列棚マスターデータを更新します。GitHubとの認証にはキーサービス経由でAPIキーが復号されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| checkoutSetting | [GitHubCheckoutSetting](#githubcheckoutsetting) | | ✓| | | GitHubからマスターデータをチェックアウトする設定 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [CurrentShowcaseMaster](#currentshowcasemaster) | 更新された現在アクティブな陳列棚のマスターデータ |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.UpdateCurrentShowcaseMasterFromGitHub(
&showcase.UpdateCurrentShowcaseMasterFromGitHubRequest {
NamespaceName: pointy.String("namespace-0001"),
CheckoutSetting: &showcase.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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\UpdateCurrentShowcaseMasterFromGitHubRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->updateCurrentShowcaseMasterFromGitHub(
(new UpdateCurrentShowcaseMasterFromGitHubRequest())
->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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.UpdateCurrentShowcaseMasterFromGitHubRequest;
import io.gs2.showcase.result.UpdateCurrentShowcaseMasterFromGitHubResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
UpdateCurrentShowcaseMasterFromGitHubResult result = client.updateCurrentShowcaseMasterFromGitHub(
new UpdateCurrentShowcaseMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
CurrentShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentShowcaseMasterFromGitHub(
new Gs2.Gs2Showcase.Request.UpdateCurrentShowcaseMasterFromGitHubRequest()
.WithNamespaceName("namespace-0001")
.WithCheckoutSetting(new Gs2.Gs2Showcase.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.updateCurrentShowcaseMasterFromGitHub(
new Gs2Showcase.UpdateCurrentShowcaseMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new Gs2Showcase.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.update_current_showcase_master_from_git_hub(
showcase.UpdateCurrentShowcaseMasterFromGitHubRequest()
.with_namespace_name('namespace-0001')
.with_checkout_setting(showcase.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('showcase')
api_result = client.update_current_showcase_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('showcase')
api_result_handler = client.update_current_showcase_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;
```
---
### describeSalesItemMasters
商品マスターの一覧を取得
商品マスターのページネーション付きリストを取得します。名前のプレフィックスでフィルタリングできます。商品マスターは商品購入時に実行される検証、消費、入手アクションを定義します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| namePrefix | string | | | | ~ 64文字 | 商品名のフィルター接頭辞 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<SalesItemMaster>](#salesitemmaster) | 商品マスターのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DescribeSalesItemMasters(
&showcase.DescribeSalesItemMastersRequest {
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DescribeSalesItemMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->describeSalesItemMasters(
(new DescribeSalesItemMastersRequest())
->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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DescribeSalesItemMastersRequest;
import io.gs2.showcase.result.DescribeSalesItemMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DescribeSalesItemMastersResult result = client.describeSalesItemMasters(
new DescribeSalesItemMastersRequest()
.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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSalesItemMasters(
new Gs2.Gs2Showcase.Request.DescribeSalesItemMastersRequest()
.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.describeSalesItemMasters(
new Gs2Showcase.DescribeSalesItemMastersRequest()
.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.describe_sales_item_masters(
showcase.DescribeSalesItemMastersRequest()
.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('showcase')
api_result = client.describe_sales_item_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('showcase')
api_result_handler = client.describe_sales_item_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;
```
---
### createSalesItemMaster
商品マスターを新規作成
検証アクション（購入前バリデーション）、消費アクション（差し引くリソース）、入手アクション（付与するリソース）を持つ新しい商品マスターを作成し、完全な購入トランザクションを定義します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string | | ✓| | ~ 128文字 | 商品名
商品固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| verifyActions | [List<VerifyAction>](#verifyaction) | | | | 0 ~ 10 items | 検証アクションリスト
購入前に実行される前提条件チェックです。すべての検証アクションが成功した後に消費・入手アクションが処理されます。購入資格の条件チェックに使用できます。 |
| consumeActions | [List<ConsumeAction>](#consumeaction) | | | | 0 ~ 10 items | 消費アクションリスト
購入対価としてリソースを消費するアクションです。商品グループの購入回数制御のために GS2-Limit の CountUp アクションを含めることができます。 |
| acquireActions | [List<AcquireAction>](#acquireaction) | | ✓| | 1 ~ 100 items | 入手アクションリスト
購入報酬としてリソースを付与するアクションです。すべての消費アクションが正常に完了した後に実行されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SalesItemMaster](#salesitemmaster) | 作成した商品マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.CreateSalesItemMaster(
&showcase.CreateSalesItemMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("sales-item-0001"),
Description: nil,
Metadata: nil,
VerifyActions: nil,
ConsumeActions: []showcase.ConsumeAction{
showcase.ConsumeAction{
Action: pointy.String("Gs2Money:WithdrawByUserId"),
Request: pointy.String("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
},
},
AcquireActions: []showcase.AcquireAction{
showcase.AcquireAction{
Action: pointy.String("Gs2Stamina:RecoverStaminaByUserId"),
Request: pointy.String("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
},
},
}
)
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\CreateSalesItemMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->createSalesItemMaster(
(new CreateSalesItemMasterRequest())
->withNamespaceName("namespace-0001")
->withName("sales-item-0001")
->withDescription(null)
->withMetadata(null)
->withVerifyActions(null)
->withConsumeActions([
(new \Gs2\Showcase\Model\ConsumeAction())
->withAction("Gs2Money:WithdrawByUserId")
->withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
])
->withAcquireActions([
(new \Gs2\Showcase\Model\AcquireAction())
->withAction("Gs2Stamina:RecoverStaminaByUserId")
->withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
])
);
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.CreateSalesItemMasterRequest;
import io.gs2.showcase.result.CreateSalesItemMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
CreateSalesItemMasterResult result = client.createSalesItemMaster(
new CreateSalesItemMasterRequest()
.withNamespaceName("namespace-0001")
.withName("sales-item-0001")
.withDescription(null)
.withMetadata(null)
.withVerifyActions(null)
.withConsumeActions(Arrays.asList(
new io.gs2.showcase.model.ConsumeAction()
.withAction("Gs2Money:WithdrawByUserId")
.withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
))
.withAcquireActions(Arrays.asList(
new io.gs2.showcase.model.AcquireAction()
.withAction("Gs2Stamina:RecoverStaminaByUserId")
.withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}")
))
);
SalesItemMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateSalesItemMaster(
new Gs2.Gs2Showcase.Request.CreateSalesItemMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("sales-item-0001")
.WithDescription(null)
.WithMetadata(null)
.WithVerifyActions(null)
.WithConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
new Gs2.Core.Model.ConsumeAction()
.WithAction("Gs2Money:WithdrawByUserId")
.WithRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
})
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Stamina:RecoverStaminaByUserId")
.WithRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
}),
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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.createSalesItemMaster(
new Gs2Showcase.CreateSalesItemMasterRequest()
.withNamespaceName("namespace-0001")
.withName("sales-item-0001")
.withDescription(null)
.withMetadata(null)
.withVerifyActions(null)
.withConsumeActions([
new Gs2Showcase.model.ConsumeAction()
.withAction("Gs2Money:WithdrawByUserId")
.withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
])
.withAcquireActions([
new Gs2Showcase.model.AcquireAction()
.withAction("Gs2Stamina:RecoverStaminaByUserId")
.withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}"),
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.create_sales_item_master(
showcase.CreateSalesItemMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('sales-item-0001')
.with_description(None)
.with_metadata(None)
.with_verify_actions(None)
.with_consume_actions([
showcase.ConsumeAction()
.with_action('Gs2Money:WithdrawByUserId')
.with_request('{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
])
.with_acquire_actions([
showcase.AcquireAction()
.with_action('Gs2Stamina:RecoverStaminaByUserId')
.with_request('{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'),
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.create_sales_item_master({
namespaceName="namespace-0001",
name="sales-item-0001",
description=nil,
metadata=nil,
verifyActions=nil,
consumeActions={
{
action="Gs2Money:WithdrawByUserId",
request="{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
}
},
acquireActions={
{
action="Gs2Stamina:RecoverStaminaByUserId",
request="{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
}
},
})
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('showcase')
api_result_handler = client.create_sales_item_master_async({
namespaceName="namespace-0001",
name="sales-item-0001",
description=nil,
metadata=nil,
verifyActions=nil,
consumeActions={
{
action="Gs2Money:WithdrawByUserId",
request="{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
}
},
acquireActions={
{
action="Gs2Stamina:RecoverStaminaByUserId",
request="{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 100, \"paidOnly\": false}",
}
},
})
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;
```
---
### getSalesItemMaster
商品マスターを取得
検証、消費、入手アクションの設定を含む、指定された商品マスターを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| salesItemName | string | | ✓| | ~ 128文字 | 商品名
商品固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SalesItemMaster](#salesitemmaster) | 商品マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetSalesItemMaster(
&showcase.GetSalesItemMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
SalesItemName: pointy.String("sales-item-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetSalesItemMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->getSalesItemMaster(
(new GetSalesItemMasterRequest())
->withNamespaceName("namespace-0001")
->withSalesItemName("sales-item-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetSalesItemMasterRequest;
import io.gs2.showcase.result.GetSalesItemMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
GetSalesItemMasterResult result = client.getSalesItemMaster(
new GetSalesItemMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemName("sales-item-0001")
);
SalesItemMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSalesItemMaster(
new Gs2.Gs2Showcase.Request.GetSalesItemMasterRequest()
.WithNamespaceName("namespace-0001")
.WithSalesItemName("sales-item-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getSalesItemMaster(
new Gs2Showcase.GetSalesItemMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemName("sales-item-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_sales_item_master(
showcase.GetSalesItemMasterRequest()
.with_namespace_name('namespace-0001')
.with_sales_item_name('sales-item-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.get_sales_item_master({
namespaceName="namespace-0001",
salesItemName="sales-item-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('showcase')
api_result_handler = client.get_sales_item_master_async({
namespaceName="namespace-0001",
salesItemName="sales-item-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;
```
---
### updateSalesItemMaster
商品マスターを更新
指定された商品マスターの説明、メタデータ、検証アクション、消費アクション、入手アクションを更新します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| salesItemName | string | | ✓| | ~ 128文字 | 商品名
商品固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| verifyActions | [List<VerifyAction>](#verifyaction) | | | | 0 ~ 10 items | 検証アクションリスト
購入前に実行される前提条件チェックです。すべての検証アクションが成功した後に消費・入手アクションが処理されます。購入資格の条件チェックに使用できます。 |
| consumeActions | [List<ConsumeAction>](#consumeaction) | | | | 0 ~ 10 items | 消費アクションリスト
購入対価としてリソースを消費するアクションです。商品グループの購入回数制御のために GS2-Limit の CountUp アクションを含めることができます。 |
| acquireActions | [List<AcquireAction>](#acquireaction) | | ✓| | 1 ~ 100 items | 入手アクションリスト
購入報酬としてリソースを付与するアクションです。すべての消費アクションが正常に完了した後に実行されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SalesItemMaster](#salesitemmaster) | 更新した商品マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.UpdateSalesItemMaster(
&showcase.UpdateSalesItemMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
SalesItemName: pointy.String("sales-item-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("SALES_ITEM_0001"),
VerifyActions: nil,
ConsumeActions: []showcase.ConsumeAction{
showcase.ConsumeAction{
Action: pointy.String("Gs2Money:WithdrawByUserId"),
Request: pointy.String("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
},
},
AcquireActions: []showcase.AcquireAction{
showcase.AcquireAction{
Action: pointy.String("Gs2Stamina:RecoverStaminaByUserId"),
Request: pointy.String("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
},
},
}
)
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\UpdateSalesItemMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->updateSalesItemMaster(
(new UpdateSalesItemMasterRequest())
->withNamespaceName("namespace-0001")
->withSalesItemName("sales-item-0001")
->withDescription("description1")
->withMetadata("SALES_ITEM_0001")
->withVerifyActions(null)
->withConsumeActions([
(new \Gs2\Showcase\Model\ConsumeAction())
->withAction("Gs2Money:WithdrawByUserId")
->withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
])
->withAcquireActions([
(new \Gs2\Showcase\Model\AcquireAction())
->withAction("Gs2Stamina:RecoverStaminaByUserId")
->withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
])
);
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.UpdateSalesItemMasterRequest;
import io.gs2.showcase.result.UpdateSalesItemMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
UpdateSalesItemMasterResult result = client.updateSalesItemMaster(
new UpdateSalesItemMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemName("sales-item-0001")
.withDescription("description1")
.withMetadata("SALES_ITEM_0001")
.withVerifyActions(null)
.withConsumeActions(Arrays.asList(
new io.gs2.showcase.model.ConsumeAction()
.withAction("Gs2Money:WithdrawByUserId")
.withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}")
))
.withAcquireActions(Arrays.asList(
new io.gs2.showcase.model.AcquireAction()
.withAction("Gs2Stamina:RecoverStaminaByUserId")
.withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}")
))
);
SalesItemMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateSalesItemMaster(
new Gs2.Gs2Showcase.Request.UpdateSalesItemMasterRequest()
.WithNamespaceName("namespace-0001")
.WithSalesItemName("sales-item-0001")
.WithDescription("description1")
.WithMetadata("SALES_ITEM_0001")
.WithVerifyActions(null)
.WithConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
new Gs2.Core.Model.ConsumeAction()
.WithAction("Gs2Money:WithdrawByUserId")
.WithRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
})
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Stamina:RecoverStaminaByUserId")
.WithRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
}),
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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.updateSalesItemMaster(
new Gs2Showcase.UpdateSalesItemMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemName("sales-item-0001")
.withDescription("description1")
.withMetadata("SALES_ITEM_0001")
.withVerifyActions(null)
.withConsumeActions([
new Gs2Showcase.model.ConsumeAction()
.withAction("Gs2Money:WithdrawByUserId")
.withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
])
.withAcquireActions([
new Gs2Showcase.model.AcquireAction()
.withAction("Gs2Stamina:RecoverStaminaByUserId")
.withRequest("{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}"),
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.update_sales_item_master(
showcase.UpdateSalesItemMasterRequest()
.with_namespace_name('namespace-0001')
.with_sales_item_name('sales-item-0001')
.with_description('description1')
.with_metadata('SALES_ITEM_0001')
.with_verify_actions(None)
.with_consume_actions([
showcase.ConsumeAction()
.with_action('Gs2Money:WithdrawByUserId')
.with_request('{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}'),
])
.with_acquire_actions([
showcase.AcquireAction()
.with_action('Gs2Stamina:RecoverStaminaByUserId')
.with_request('{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}'),
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.update_sales_item_master({
namespaceName="namespace-0001",
salesItemName="sales-item-0001",
description="description1",
metadata="SALES_ITEM_0001",
verifyActions=nil,
consumeActions={
{
action="Gs2Money:WithdrawByUserId",
request="{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}",
}
},
acquireActions={
{
action="Gs2Stamina:RecoverStaminaByUserId",
request="{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}",
}
},
})
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('showcase')
api_result_handler = client.update_sales_item_master_async({
namespaceName="namespace-0001",
salesItemName="sales-item-0001",
description="description1",
metadata="SALES_ITEM_0001",
verifyActions=nil,
consumeActions={
{
action="Gs2Money:WithdrawByUserId",
request="{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}",
}
},
acquireActions={
{
action="Gs2Stamina:RecoverStaminaByUserId",
request="{\"moneyName\": \"money-0001\", \"userId\": \"user-0001\", \"slot\": 0, \"count\": 200, \"paidOnly\": false}",
}
},
})
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;
```
---
### deleteSalesItemMaster
商品マスターを削除
指定された商品マスターを削除します。これはマスター定義のみを削除し、現在アクティブな陳列棚には影響しません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| salesItemName | string | | ✓| | ~ 128文字 | 商品名
商品固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SalesItemMaster](#salesitemmaster) | 削除した商品マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DeleteSalesItemMaster(
&showcase.DeleteSalesItemMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
SalesItemName: pointy.String("sales-item-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DeleteSalesItemMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->deleteSalesItemMaster(
(new DeleteSalesItemMasterRequest())
->withNamespaceName("namespace-0001")
->withSalesItemName("sales-item-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DeleteSalesItemMasterRequest;
import io.gs2.showcase.result.DeleteSalesItemMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DeleteSalesItemMasterResult result = client.deleteSalesItemMaster(
new DeleteSalesItemMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemName("sales-item-0001")
);
SalesItemMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteSalesItemMaster(
new Gs2.Gs2Showcase.Request.DeleteSalesItemMasterRequest()
.WithNamespaceName("namespace-0001")
.WithSalesItemName("sales-item-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.deleteSalesItemMaster(
new Gs2Showcase.DeleteSalesItemMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemName("sales-item-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.delete_sales_item_master(
showcase.DeleteSalesItemMasterRequest()
.with_namespace_name('namespace-0001')
.with_sales_item_name('sales-item-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.delete_sales_item_master({
namespaceName="namespace-0001",
salesItemName="sales-item-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('showcase')
api_result_handler = client.delete_sales_item_master_async({
namespaceName="namespace-0001",
salesItemName="sales-item-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;
```
---
### describeSalesItemGroupMasters
商品グループマスターの一覧を取得
商品グループマスターのページネーション付きリストを取得します。名前のプレフィックスでフィルタリングできます。商品グループマスターは複数の商品をまとめて陳列棚に表示するためにバンドルします。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| namePrefix | string | | | | ~ 64文字 | 商品グループ名のフィルター接頭辞 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<SalesItemGroupMaster>](#salesitemgroupmaster) | 商品グループマスターのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DescribeSalesItemGroupMasters(
&showcase.DescribeSalesItemGroupMastersRequest {
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DescribeSalesItemGroupMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->describeSalesItemGroupMasters(
(new DescribeSalesItemGroupMastersRequest())
->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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DescribeSalesItemGroupMastersRequest;
import io.gs2.showcase.result.DescribeSalesItemGroupMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DescribeSalesItemGroupMastersResult result = client.describeSalesItemGroupMasters(
new DescribeSalesItemGroupMastersRequest()
.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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSalesItemGroupMasters(
new Gs2.Gs2Showcase.Request.DescribeSalesItemGroupMastersRequest()
.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.describeSalesItemGroupMasters(
new Gs2Showcase.DescribeSalesItemGroupMastersRequest()
.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.describe_sales_item_group_masters(
showcase.DescribeSalesItemGroupMastersRequest()
.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('showcase')
api_result = client.describe_sales_item_group_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('showcase')
api_result_handler = client.describe_sales_item_group_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;
```
---
### createSalesItemGroupMaster
商品グループマスターを新規作成
名前、メタデータ、およびグループに属する商品名のリストを持つ新しい商品グループマスターを作成します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string | | ✓| | ~ 128文字 | 商品グループ名
商品グループ固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| salesItemNames | List<string> | | ✓| | 2 ~ 10 items | 商品グループに含める商品リスト
このグループ内の商品名の順序付きリストです。GS2-Limit カウンターを使って先頭から順に購入可能かを判定し、最初に購入可能と判定された商品が表示されます。いずれも該当しない場合、リストの最後の商品がフォールバックとして使用されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SalesItemGroupMaster](#salesitemgroupmaster) | 作成した商品グループマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.CreateSalesItemGroupMaster(
&showcase.CreateSalesItemGroupMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("sales-item-group-0001"),
Description: nil,
Metadata: nil,
SalesItemNames: []*string{
pointy.String("salesItem-0001"),
pointy.String("salesItem-0002"),
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\CreateSalesItemGroupMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->createSalesItemGroupMaster(
(new CreateSalesItemGroupMasterRequest())
->withNamespaceName("namespace-0001")
->withName("sales-item-group-0001")
->withDescription(null)
->withMetadata(null)
->withSalesItemNames([
"salesItem-0001",
"salesItem-0002",
])
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.CreateSalesItemGroupMasterRequest;
import io.gs2.showcase.result.CreateSalesItemGroupMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
CreateSalesItemGroupMasterResult result = client.createSalesItemGroupMaster(
new CreateSalesItemGroupMasterRequest()
.withNamespaceName("namespace-0001")
.withName("sales-item-group-0001")
.withDescription(null)
.withMetadata(null)
.withSalesItemNames(Arrays.asList(
"salesItem-0001",
"salesItem-0002"
))
);
SalesItemGroupMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateSalesItemGroupMaster(
new Gs2.Gs2Showcase.Request.CreateSalesItemGroupMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("sales-item-group-0001")
.WithDescription(null)
.WithMetadata(null)
.WithSalesItemNames(new string[] {
"salesItem-0001",
"salesItem-0002",
}),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.createSalesItemGroupMaster(
new Gs2Showcase.CreateSalesItemGroupMasterRequest()
.withNamespaceName("namespace-0001")
.withName("sales-item-group-0001")
.withDescription(null)
.withMetadata(null)
.withSalesItemNames([
"salesItem-0001",
"salesItem-0002",
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.create_sales_item_group_master(
showcase.CreateSalesItemGroupMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('sales-item-group-0001')
.with_description(None)
.with_metadata(None)
.with_sales_item_names([
'salesItem-0001',
'salesItem-0002',
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.create_sales_item_group_master({
namespaceName="namespace-0001",
name="sales-item-group-0001",
description=nil,
metadata=nil,
salesItemNames={
"salesItem-0001",
"salesItem-0002"
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('showcase')
api_result_handler = client.create_sales_item_group_master_async({
namespaceName="namespace-0001",
name="sales-item-group-0001",
description=nil,
metadata=nil,
salesItemNames={
"salesItem-0001",
"salesItem-0002"
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getSalesItemGroupMaster
商品グループマスターを取得
所属する商品名のリストを含む、指定された商品グループマスターを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| salesItemGroupName | string | | ✓| | ~ 128文字 | 商品グループ名
商品グループ固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SalesItemGroupMaster](#salesitemgroupmaster) | 商品グループマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetSalesItemGroupMaster(
&showcase.GetSalesItemGroupMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
SalesItemGroupName: pointy.String("sales-item-group-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetSalesItemGroupMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->getSalesItemGroupMaster(
(new GetSalesItemGroupMasterRequest())
->withNamespaceName("namespace-0001")
->withSalesItemGroupName("sales-item-group-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetSalesItemGroupMasterRequest;
import io.gs2.showcase.result.GetSalesItemGroupMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
GetSalesItemGroupMasterResult result = client.getSalesItemGroupMaster(
new GetSalesItemGroupMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemGroupName("sales-item-group-0001")
);
SalesItemGroupMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSalesItemGroupMaster(
new Gs2.Gs2Showcase.Request.GetSalesItemGroupMasterRequest()
.WithNamespaceName("namespace-0001")
.WithSalesItemGroupName("sales-item-group-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getSalesItemGroupMaster(
new Gs2Showcase.GetSalesItemGroupMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemGroupName("sales-item-group-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_sales_item_group_master(
showcase.GetSalesItemGroupMasterRequest()
.with_namespace_name('namespace-0001')
.with_sales_item_group_name('sales-item-group-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.get_sales_item_group_master({
namespaceName="namespace-0001",
salesItemGroupName="sales-item-group-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('showcase')
api_result_handler = client.get_sales_item_group_master_async({
namespaceName="namespace-0001",
salesItemGroupName="sales-item-group-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;
```
---
### updateSalesItemGroupMaster
商品グループマスターを更新
指定された商品グループマスターの説明、メタデータ、所属する商品名のリストを更新します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| salesItemGroupName | string | | ✓| | ~ 128文字 | 商品グループ名
商品グループ固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| salesItemNames | List<string> | | ✓| | 2 ~ 10 items | 商品グループに含める商品リスト
このグループ内の商品名の順序付きリストです。GS2-Limit カウンターを使って先頭から順に購入可能かを判定し、最初に購入可能と判定された商品が表示されます。いずれも該当しない場合、リストの最後の商品がフォールバックとして使用されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SalesItemGroupMaster](#salesitemgroupmaster) | 更新した商品グループマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.UpdateSalesItemGroupMaster(
&showcase.UpdateSalesItemGroupMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
SalesItemGroupName: pointy.String("sales-item-group-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("SALES_ITEM_GROUP_0001"),
SalesItemNames: []*string{
pointy.String("salesItem-0001"),
pointy.String("salesItem-0002"),
pointy.String("salesItem-0003"),
},
}
)
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\UpdateSalesItemGroupMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->updateSalesItemGroupMaster(
(new UpdateSalesItemGroupMasterRequest())
->withNamespaceName("namespace-0001")
->withSalesItemGroupName("sales-item-group-0001")
->withDescription("description1")
->withMetadata("SALES_ITEM_GROUP_0001")
->withSalesItemNames([
"salesItem-0001",
"salesItem-0002",
"salesItem-0003",
])
);
$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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.UpdateSalesItemGroupMasterRequest;
import io.gs2.showcase.result.UpdateSalesItemGroupMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
UpdateSalesItemGroupMasterResult result = client.updateSalesItemGroupMaster(
new UpdateSalesItemGroupMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemGroupName("sales-item-group-0001")
.withDescription("description1")
.withMetadata("SALES_ITEM_GROUP_0001")
.withSalesItemNames(Arrays.asList(
"salesItem-0001",
"salesItem-0002",
"salesItem-0003"
))
);
SalesItemGroupMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateSalesItemGroupMaster(
new Gs2.Gs2Showcase.Request.UpdateSalesItemGroupMasterRequest()
.WithNamespaceName("namespace-0001")
.WithSalesItemGroupName("sales-item-group-0001")
.WithDescription("description1")
.WithMetadata("SALES_ITEM_GROUP_0001")
.WithSalesItemNames(new string[] {
"salesItem-0001",
"salesItem-0002",
"salesItem-0003",
}),
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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.updateSalesItemGroupMaster(
new Gs2Showcase.UpdateSalesItemGroupMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemGroupName("sales-item-group-0001")
.withDescription("description1")
.withMetadata("SALES_ITEM_GROUP_0001")
.withSalesItemNames([
"salesItem-0001",
"salesItem-0002",
"salesItem-0003",
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.update_sales_item_group_master(
showcase.UpdateSalesItemGroupMasterRequest()
.with_namespace_name('namespace-0001')
.with_sales_item_group_name('sales-item-group-0001')
.with_description('description1')
.with_metadata('SALES_ITEM_GROUP_0001')
.with_sales_item_names([
'salesItem-0001',
'salesItem-0002',
'salesItem-0003',
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.update_sales_item_group_master({
namespaceName="namespace-0001",
salesItemGroupName="sales-item-group-0001",
description="description1",
metadata="SALES_ITEM_GROUP_0001",
salesItemNames={
"salesItem-0001",
"salesItem-0002",
"salesItem-0003"
},
})
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('showcase')
api_result_handler = client.update_sales_item_group_master_async({
namespaceName="namespace-0001",
salesItemGroupName="sales-item-group-0001",
description="description1",
metadata="SALES_ITEM_GROUP_0001",
salesItemNames={
"salesItem-0001",
"salesItem-0002",
"salesItem-0003"
},
})
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;
```
---
### deleteSalesItemGroupMaster
商品グループマスターを削除
指定された商品グループマスターを削除します。これはマスター定義のみを削除し、現在アクティブな陳列棚には影響しません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| salesItemGroupName | string | | ✓| | ~ 128文字 | 商品グループ名
商品グループ固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [SalesItemGroupMaster](#salesitemgroupmaster) | 削除した商品グループマスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DeleteSalesItemGroupMaster(
&showcase.DeleteSalesItemGroupMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
SalesItemGroupName: pointy.String("sales-item-group-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DeleteSalesItemGroupMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->deleteSalesItemGroupMaster(
(new DeleteSalesItemGroupMasterRequest())
->withNamespaceName("namespace-0001")
->withSalesItemGroupName("sales-item-group-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DeleteSalesItemGroupMasterRequest;
import io.gs2.showcase.result.DeleteSalesItemGroupMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DeleteSalesItemGroupMasterResult result = client.deleteSalesItemGroupMaster(
new DeleteSalesItemGroupMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemGroupName("sales-item-group-0001")
);
SalesItemGroupMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteSalesItemGroupMaster(
new Gs2.Gs2Showcase.Request.DeleteSalesItemGroupMasterRequest()
.WithNamespaceName("namespace-0001")
.WithSalesItemGroupName("sales-item-group-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.deleteSalesItemGroupMaster(
new Gs2Showcase.DeleteSalesItemGroupMasterRequest()
.withNamespaceName("namespace-0001")
.withSalesItemGroupName("sales-item-group-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.delete_sales_item_group_master(
showcase.DeleteSalesItemGroupMasterRequest()
.with_namespace_name('namespace-0001')
.with_sales_item_group_name('sales-item-group-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.delete_sales_item_group_master({
namespaceName="namespace-0001",
salesItemGroupName="sales-item-group-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('showcase')
api_result_handler = client.delete_sales_item_group_master_async({
namespaceName="namespace-0001",
salesItemGroupName="sales-item-group-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;
```
---
### describeShowcaseMasters
陳列棚マスターの一覧を取得
陳列棚マスターのページネーション付きリストを取得します。名前のプレフィックスでフィルタリングできます。陳列棚マスターは各陳列棚の陳列商品と販売期間イベントを定義します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| namePrefix | string | | | | ~ 64文字 | 陳列棚名のフィルター接頭辞 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<ShowcaseMaster>](#showcasemaster) | 陳列棚マスターのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DescribeShowcaseMasters(
&showcase.DescribeShowcaseMastersRequest {
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DescribeShowcaseMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->describeShowcaseMasters(
(new DescribeShowcaseMastersRequest())
->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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DescribeShowcaseMastersRequest;
import io.gs2.showcase.result.DescribeShowcaseMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DescribeShowcaseMastersResult result = client.describeShowcaseMasters(
new DescribeShowcaseMastersRequest()
.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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeShowcaseMasters(
new Gs2.Gs2Showcase.Request.DescribeShowcaseMastersRequest()
.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.describeShowcaseMasters(
new Gs2Showcase.DescribeShowcaseMastersRequest()
.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.describe_showcase_masters(
showcase.DescribeShowcaseMastersRequest()
.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('showcase')
api_result = client.describe_showcase_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('showcase')
api_result_handler = client.describe_showcase_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;
```
---
### createShowcaseMaster
陳列棚マスターを新規作成
名前、陳列商品、メタデータ、およびユーザーに陳列棚が利用可能な期間を制御するオプションの販売期間イベントIDを持つ新しい陳列棚マスターを作成します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string | | ✓| | ~ 128文字 | 陳列棚名
陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| displayItems | [List<DisplayItemMaster>](#displayitemmaster) | | ✓| | 1 ~ 1000 items | 陳列する商品リスト
この陳列棚に陳列される商品のリストです。各陳列商品は単一の商品または商品グループのいずれかです。販売期間イベントが終了または無効な商品は、陳列棚の取得時に自動的にフィルタリングされます。 |
| salesPeriodEventId | string | | | | ~ 1024文字 | 陳列棚の販売期間を設定した GS2-Schedule のイベントGRN
この陳列棚全体の販売期間を制御します。指定した場合、関連する GS2-Schedule のイベント期間中のみ陳列棚が利用可能になります。イベントが有効でない場合、陳列棚は空で返されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [ShowcaseMaster](#showcasemaster) | 作成した陳列棚マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.CreateShowcaseMaster(
&showcase.CreateShowcaseMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("showcase-0001"),
Description: nil,
Metadata: nil,
DisplayItems: []showcase.DisplayItemMaster{
showcase.DisplayItemMaster{
Type: pointy.String("salesItem"),
SalesItemName: pointy.String("salesItem-0001"),
},
showcase.DisplayItemMaster{
Type: pointy.String("salesItemGroup"),
SalesItemGroupName: pointy.String("salesItemGroup-0001"),
SalesPeriodEventId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001"),
},
},
SalesPeriodEventId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\CreateShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->createShowcaseMaster(
(new CreateShowcaseMasterRequest())
->withNamespaceName("namespace-0001")
->withName("showcase-0001")
->withDescription(null)
->withMetadata(null)
->withDisplayItems([
(new \Gs2\Showcase\Model\DisplayItemMaster())
->withType("salesItem")
->withSalesItemName("salesItem-0001"),
(new \Gs2\Showcase\Model\DisplayItemMaster())
->withType("salesItemGroup")
->withSalesItemGroupName("salesItemGroup-0001")
->withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001"),
])
->withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.CreateShowcaseMasterRequest;
import io.gs2.showcase.result.CreateShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
CreateShowcaseMasterResult result = client.createShowcaseMaster(
new CreateShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withName("showcase-0001")
.withDescription(null)
.withMetadata(null)
.withDisplayItems(Arrays.asList(
new io.gs2.showcase.model.DisplayItemMaster()
.withType("salesItem")
.withSalesItemName("salesItem-0001"),
new io.gs2.showcase.model.DisplayItemMaster()
.withType("salesItemGroup")
.withSalesItemGroupName("salesItemGroup-0001")
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001")
))
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001")
);
ShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateShowcaseMaster(
new Gs2.Gs2Showcase.Request.CreateShowcaseMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("showcase-0001")
.WithDescription(null)
.WithMetadata(null)
.WithDisplayItems(new Gs2.Gs2Showcase.Model.DisplayItemMaster[] {
new Gs2.Gs2Showcase.Model.DisplayItemMaster()
.WithType("salesItem")
.WithSalesItemName("salesItem-0001"),
new Gs2.Gs2Showcase.Model.DisplayItemMaster()
.WithType("salesItemGroup")
.WithSalesItemGroupName("salesItemGroup-0001")
.WithSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001"),
})
.WithSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.createShowcaseMaster(
new Gs2Showcase.CreateShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withName("showcase-0001")
.withDescription(null)
.withMetadata(null)
.withDisplayItems([
new Gs2Showcase.model.DisplayItemMaster()
.withType("salesItem")
.withSalesItemName("salesItem-0001"),
new Gs2Showcase.model.DisplayItemMaster()
.withType("salesItemGroup")
.withSalesItemGroupName("salesItemGroup-0001")
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001"),
])
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.create_showcase_master(
showcase.CreateShowcaseMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('showcase-0001')
.with_description(None)
.with_metadata(None)
.with_display_items([
showcase.DisplayItemMaster()
.with_type('salesItem')
.with_sales_item_name('salesItem-0001'),
showcase.DisplayItemMaster()
.with_type('salesItemGroup')
.with_sales_item_group_name('salesItemGroup-0001')
.with_sales_period_event_id('grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001'),
])
.with_sales_period_event_id('grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.create_showcase_master({
namespaceName="namespace-0001",
name="showcase-0001",
description=nil,
metadata=nil,
displayItems={
{
type="salesItem",
salesItemName="salesItem-0001",
},
{
type="salesItemGroup",
salesItemGroupName="salesItemGroup-0001",
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001",
}
},
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-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('showcase')
api_result_handler = client.create_showcase_master_async({
namespaceName="namespace-0001",
name="showcase-0001",
description=nil,
metadata=nil,
displayItems={
{
type="salesItem",
salesItemName="salesItem-0001",
},
{
type="salesItemGroup",
salesItemGroupName="salesItemGroup-0001",
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001",
}
},
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-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;
```
---
### getShowcaseMaster
陳列棚マスターを取得
陳列商品、メタデータ、販売期間イベント設定を含む、指定された陳列棚マスターを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | 陳列棚名
陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [ShowcaseMaster](#showcasemaster) | 陳列棚マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetShowcaseMaster(
&showcase.GetShowcaseMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->getShowcaseMaster(
(new GetShowcaseMasterRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetShowcaseMasterRequest;
import io.gs2.showcase.result.GetShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
GetShowcaseMasterResult result = client.getShowcaseMaster(
new GetShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
);
ShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetShowcaseMaster(
new Gs2.Gs2Showcase.Request.GetShowcaseMasterRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getShowcaseMaster(
new Gs2Showcase.GetShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_showcase_master(
showcase.GetShowcaseMasterRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.get_showcase_master({
namespaceName="namespace-0001",
showcaseName="showcase-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('showcase')
api_result_handler = client.get_showcase_master_async({
namespaceName="namespace-0001",
showcaseName="showcase-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;
```
---
### updateShowcaseMaster
陳列棚マスターを更新
指定された陳列棚マスターの説明、メタデータ、陳列商品、販売期間イベント設定を更新します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | 陳列棚名
陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| displayItems | [List<DisplayItemMaster>](#displayitemmaster) | | ✓| | 1 ~ 1000 items | 陳列する商品リスト
この陳列棚に陳列される商品のリストです。各陳列商品は単一の商品または商品グループのいずれかです。販売期間イベントが終了または無効な商品は、陳列棚の取得時に自動的にフィルタリングされます。 |
| salesPeriodEventId | string | | | | ~ 1024文字 | 陳列棚の販売期間を設定した GS2-Schedule のイベントGRN
この陳列棚全体の販売期間を制御します。指定した場合、関連する GS2-Schedule のイベント期間中のみ陳列棚が利用可能になります。イベントが有効でない場合、陳列棚は空で返されます。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [ShowcaseMaster](#showcasemaster) | 更新した陳列棚マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.UpdateShowcaseMaster(
&showcase.UpdateShowcaseMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("SHOWCASE_0001"),
DisplayItems: []showcase.DisplayItemMaster{
showcase.DisplayItemMaster{
Type: pointy.String("salesItem"),
SalesItemName: pointy.String("salesItem-0003"),
},
showcase.DisplayItemMaster{
Type: pointy.String("salesItemGroup"),
SalesItemGroupName: pointy.String("salesItemGroup-0001"),
SalesPeriodEventId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001"),
},
},
SalesPeriodEventId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\UpdateShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->updateShowcaseMaster(
(new UpdateShowcaseMasterRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDescription("description1")
->withMetadata("SHOWCASE_0001")
->withDisplayItems([
(new \Gs2\Showcase\Model\DisplayItemMaster())
->withType("salesItem")
->withSalesItemName("salesItem-0003"),
(new \Gs2\Showcase\Model\DisplayItemMaster())
->withType("salesItemGroup")
->withSalesItemGroupName("salesItemGroup-0001")
->withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001"),
])
->withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.UpdateShowcaseMasterRequest;
import io.gs2.showcase.result.UpdateShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
UpdateShowcaseMasterResult result = client.updateShowcaseMaster(
new UpdateShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDescription("description1")
.withMetadata("SHOWCASE_0001")
.withDisplayItems(Arrays.asList(
new io.gs2.showcase.model.DisplayItemMaster()
.withType("salesItem")
.withSalesItemName("salesItem-0003"),
new io.gs2.showcase.model.DisplayItemMaster()
.withType("salesItemGroup")
.withSalesItemGroupName("salesItemGroup-0001")
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001")
))
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
);
ShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateShowcaseMaster(
new Gs2.Gs2Showcase.Request.UpdateShowcaseMasterRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDescription("description1")
.WithMetadata("SHOWCASE_0001")
.WithDisplayItems(new Gs2.Gs2Showcase.Model.DisplayItemMaster[] {
new Gs2.Gs2Showcase.Model.DisplayItemMaster()
.WithType("salesItem")
.WithSalesItemName("salesItem-0003"),
new Gs2.Gs2Showcase.Model.DisplayItemMaster()
.WithType("salesItemGroup")
.WithSalesItemGroupName("salesItemGroup-0001")
.WithSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001"),
})
.WithSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.updateShowcaseMaster(
new Gs2Showcase.UpdateShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDescription("description1")
.withMetadata("SHOWCASE_0001")
.withDisplayItems([
new Gs2Showcase.model.DisplayItemMaster()
.withType("salesItem")
.withSalesItemName("salesItem-0003"),
new Gs2Showcase.model.DisplayItemMaster()
.withType("salesItemGroup")
.withSalesItemGroupName("salesItemGroup-0001")
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001"),
])
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.update_showcase_master(
showcase.UpdateShowcaseMasterRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_description('description1')
.with_metadata('SHOWCASE_0001')
.with_display_items([
showcase.DisplayItemMaster()
.with_type('salesItem')
.with_sales_item_name('salesItem-0003'),
showcase.DisplayItemMaster()
.with_type('salesItemGroup')
.with_sales_item_group_name('salesItemGroup-0001')
.with_sales_period_event_id('grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001'),
])
.with_sales_period_event_id('grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.update_showcase_master({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
description="description1",
metadata="SHOWCASE_0001",
displayItems={
{
type="salesItem",
salesItemName="salesItem-0003",
},
{
type="salesItemGroup",
salesItemGroupName="salesItemGroup-0001",
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001",
}
},
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('showcase')
api_result_handler = client.update_showcase_master_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
description="description1",
metadata="SHOWCASE_0001",
displayItems={
{
type="salesItem",
salesItemName="salesItem-0003",
},
{
type="salesItemGroup",
salesItemGroupName="salesItemGroup-0001",
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001",
}
},
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteShowcaseMaster
陳列棚マスターを削除
指定された陳列棚マスターを削除します。これはマスター定義のみを削除し、現在アクティブな陳列棚には影響しません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | 陳列棚名
陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [ShowcaseMaster](#showcasemaster) | 削除した陳列棚マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DeleteShowcaseMaster(
&showcase.DeleteShowcaseMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DeleteShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->deleteShowcaseMaster(
(new DeleteShowcaseMasterRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DeleteShowcaseMasterRequest;
import io.gs2.showcase.result.DeleteShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DeleteShowcaseMasterResult result = client.deleteShowcaseMaster(
new DeleteShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
);
ShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteShowcaseMaster(
new Gs2.Gs2Showcase.Request.DeleteShowcaseMasterRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.deleteShowcaseMaster(
new Gs2Showcase.DeleteShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.delete_showcase_master(
showcase.DeleteShowcaseMasterRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.delete_showcase_master({
namespaceName="namespace-0001",
showcaseName="showcase-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('showcase')
api_result_handler = client.delete_showcase_master_async({
namespaceName="namespace-0001",
showcaseName="showcase-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;
```
---
### describeRandomShowcaseMasters
ランダム陳列棚マスターの一覧を取得
ランダム陳列棚マスターのページネーション付きリストを取得します。名前のプレフィックスでフィルタリングできます。ランダム陳列棚マスターは商品プール、最大表示数、ローテーションタイミング、販売期間イベントを定義します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| namePrefix | string | | | | ~ 64文字 | ランダム陳列棚名のフィルター接頭辞 |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<RandomShowcaseMaster>](#randomshowcasemaster) | ランダム陳列棚マスターのリスト |
| nextPageToken | string | リストの続きを取得するためのページトークン |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DescribeRandomShowcaseMasters(
&showcase.DescribeRandomShowcaseMastersRequest {
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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DescribeRandomShowcaseMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->describeRandomShowcaseMasters(
(new DescribeRandomShowcaseMastersRequest())
->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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DescribeRandomShowcaseMastersRequest;
import io.gs2.showcase.result.DescribeRandomShowcaseMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DescribeRandomShowcaseMastersResult result = client.describeRandomShowcaseMasters(
new DescribeRandomShowcaseMastersRequest()
.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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeRandomShowcaseMasters(
new Gs2.Gs2Showcase.Request.DescribeRandomShowcaseMastersRequest()
.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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.describeRandomShowcaseMasters(
new Gs2Showcase.DescribeRandomShowcaseMastersRequest()
.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 showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.describe_random_showcase_masters(
showcase.DescribeRandomShowcaseMastersRequest()
.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('showcase')
api_result = client.describe_random_showcase_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('showcase')
api_result_handler = client.describe_random_showcase_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;
```
---
### createRandomShowcaseMaster
ランダム陳列棚マスターを新規作成
最大表示数、陳列商品プール、基準タイムスタンプ、商品ローテーションのリセット間隔（時間）、およびオプションの販売期間イベントIDを持つ新しいランダム陳列棚マスターを作成します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| name | string | | ✓| | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| maximumNumberOfChoice | int | | ✓| | 1 ~ 100 | 選出される商品の最大数
各ローテーション期間に商品プールからランダムに抽選される商品の数です。重み付きランダム選択で重複なく抽選されるため、1回のローテーションで同じ商品が2回表示されることはありません。 |
| displayItems | [List<RandomDisplayItemModel>](#randomdisplayitemmodel) | | ✓| | 1 ~ 100 items | 選出対象のランダム陳列商品リスト
商品がランダムに抽選される候補アイテムのプールです。各アイテムには選択確率を決定する重みと、ローテーション全体で表示可能な回数を制限する在庫数があります。 |
| baseTimestamp | long | | ✓| | | 陳列する商品を再抽選する基準時刻
ローテーション境界の計算に使用される基準タイムスタンプです。この基準時間から一定間隔（resetIntervalHours）ごとに商品の再抽選が行われます。過去の時刻を指定する必要があります。 |
| resetIntervalHours | int | | ✓| | 1 ~ 168 | 陳列する商品を再抽選する間隔（時）
各商品ローテーション間の時間数です。baseTimestamp を基準として間隔が経過すると、新しい乱数シードで陳列商品が再抽選されます。1〜168時間（1週間）の範囲で設定できます。 |
| salesPeriodEventId | string | | | | ~ 1024文字 | 陳列棚の販売期間を設定した GS2-Schedule のイベントGRN
このランダム陳列棚全体の販売期間を制御します。指定した場合、関連する GS2-Schedule のイベント期間中のみ陳列棚が利用可能になります。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomShowcaseMaster](#randomshowcasemaster) | 作成したランダム陳列棚マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.CreateRandomShowcaseMaster(
&showcase.CreateRandomShowcaseMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("showcase-0001"),
Description: nil,
Metadata: nil,
MaximumNumberOfChoice: pointy.Int32(2),
DisplayItems: []showcase.RandomDisplayItemModel{
showcase.RandomDisplayItemModel{
Name: pointy.String("display-item-0001"),
ConsumeActions: []showcase.ConsumeAction{
showcase.ConsumeAction{
Action: pointy.String("Gs2Inventory:ConsumeItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
},
},
AcquireActions: []showcase.AcquireAction{
showcase.AcquireAction{
Action: pointy.String("Gs2Inventory:AcquireItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
},
},
Stock: pointy.Int32(1),
Weight: pointy.Int32(1),
},
showcase.RandomDisplayItemModel{
Name: pointy.String("display-item-0002"),
ConsumeActions: []showcase.ConsumeAction{
showcase.ConsumeAction{
Action: pointy.String("Gs2Inventory:ConsumeItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
},
},
AcquireActions: []showcase.AcquireAction{
showcase.AcquireAction{
Action: pointy.String("Gs2Inventory:AcquireItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
},
},
Stock: pointy.Int32(2),
Weight: pointy.Int32(2),
},
showcase.RandomDisplayItemModel{
Name: pointy.String("display-item-0003"),
ConsumeActions: []showcase.ConsumeAction{
showcase.ConsumeAction{
Action: pointy.String("Gs2Inventory:ConsumeItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
},
},
AcquireActions: []showcase.AcquireAction{
showcase.AcquireAction{
Action: pointy.String("Gs2Inventory:AcquireItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
},
},
Stock: pointy.Int32(3),
Weight: pointy.Int32(3),
},
},
BaseTimestamp: pointy.Int64(1000),
ResetIntervalHours: pointy.Int32(6),
SalesPeriodEventId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\CreateRandomShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->createRandomShowcaseMaster(
(new CreateRandomShowcaseMasterRequest())
->withNamespaceName("namespace-0001")
->withName("showcase-0001")
->withDescription(null)
->withMetadata(null)
->withMaximumNumberOfChoice(2)
->withDisplayItems([
(new \Gs2\Showcase\Model\RandomDisplayItemModel())
->withName("display-item-0001")
->withConsumeActions([
(new \Gs2\Showcase\Model\ConsumeAction())
->withAction("Gs2Inventory:ConsumeItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
->withAcquireActions([
(new \Gs2\Showcase\Model\AcquireAction())
->withAction("Gs2Inventory:AcquireItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
->withStock(1)
->withWeight(1),
(new \Gs2\Showcase\Model\RandomDisplayItemModel())
->withName("display-item-0002")
->withConsumeActions([
(new \Gs2\Showcase\Model\ConsumeAction())
->withAction("Gs2Inventory:ConsumeItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
->withAcquireActions([
(new \Gs2\Showcase\Model\AcquireAction())
->withAction("Gs2Inventory:AcquireItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
->withStock(2)
->withWeight(2),
(new \Gs2\Showcase\Model\RandomDisplayItemModel())
->withName("display-item-0003")
->withConsumeActions([
(new \Gs2\Showcase\Model\ConsumeAction())
->withAction("Gs2Inventory:ConsumeItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
->withAcquireActions([
(new \Gs2\Showcase\Model\AcquireAction())
->withAction("Gs2Inventory:AcquireItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
->withStock(3)
->withWeight(3),
])
->withBaseTimestamp(1000)
->withResetIntervalHours(6)
->withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.CreateRandomShowcaseMasterRequest;
import io.gs2.showcase.result.CreateRandomShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
CreateRandomShowcaseMasterResult result = client.createRandomShowcaseMaster(
new CreateRandomShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withName("showcase-0001")
.withDescription(null)
.withMetadata(null)
.withMaximumNumberOfChoice(2)
.withDisplayItems(Arrays.asList(
new io.gs2.showcase.model.RandomDisplayItemModel()
.withName("display-item-0001")
.withConsumeActions(Arrays.asList(
new io.gs2.showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}")
))
.withAcquireActions(Arrays.asList(
new io.gs2.showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}")
))
.withStock(1)
.withWeight(1),
new io.gs2.showcase.model.RandomDisplayItemModel()
.withName("display-item-0002")
.withConsumeActions(Arrays.asList(
new io.gs2.showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}")
))
.withAcquireActions(Arrays.asList(
new io.gs2.showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}")
))
.withStock(2)
.withWeight(2),
new io.gs2.showcase.model.RandomDisplayItemModel()
.withName("display-item-0003")
.withConsumeActions(Arrays.asList(
new io.gs2.showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}")
))
.withAcquireActions(Arrays.asList(
new io.gs2.showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}")
))
.withStock(3)
.withWeight(3)
))
.withBaseTimestamp(1000L)
.withResetIntervalHours(6)
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001")
);
RandomShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateRandomShowcaseMaster(
new Gs2.Gs2Showcase.Request.CreateRandomShowcaseMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("showcase-0001")
.WithDescription(null)
.WithMetadata(null)
.WithMaximumNumberOfChoice(2)
.WithDisplayItems(new Gs2.Gs2Showcase.Model.RandomDisplayItemModel[] {
new Gs2.Gs2Showcase.Model.RandomDisplayItemModel()
.WithName("display-item-0001")
.WithConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
new Gs2.Core.Model.ConsumeAction()
.WithAction("Gs2Inventory:ConsumeItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
})
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Inventory:AcquireItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
})
.WithStock(1)
.WithWeight(1),
new Gs2.Gs2Showcase.Model.RandomDisplayItemModel()
.WithName("display-item-0002")
.WithConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
new Gs2.Core.Model.ConsumeAction()
.WithAction("Gs2Inventory:ConsumeItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
})
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Inventory:AcquireItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
})
.WithStock(2)
.WithWeight(2),
new Gs2.Gs2Showcase.Model.RandomDisplayItemModel()
.WithName("display-item-0003")
.WithConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
new Gs2.Core.Model.ConsumeAction()
.WithAction("Gs2Inventory:ConsumeItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
})
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Inventory:AcquireItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
})
.WithStock(3)
.WithWeight(3),
})
.WithBaseTimestamp(1000L)
.WithResetIntervalHours(6)
.WithSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.createRandomShowcaseMaster(
new Gs2Showcase.CreateRandomShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withName("showcase-0001")
.withDescription(null)
.withMetadata(null)
.withMaximumNumberOfChoice(2)
.withDisplayItems([
new Gs2Showcase.model.RandomDisplayItemModel()
.withName("display-item-0001")
.withConsumeActions([
new Gs2Showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
.withAcquireActions([
new Gs2Showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
.withStock(1)
.withWeight(1),
new Gs2Showcase.model.RandomDisplayItemModel()
.withName("display-item-0002")
.withConsumeActions([
new Gs2Showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
.withAcquireActions([
new Gs2Showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
.withStock(2)
.withWeight(2),
new Gs2Showcase.model.RandomDisplayItemModel()
.withName("display-item-0003")
.withConsumeActions([
new Gs2Showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
.withAcquireActions([
new Gs2Showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
.withStock(3)
.withWeight(3),
])
.withBaseTimestamp(1000)
.withResetIntervalHours(6)
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.create_random_showcase_master(
showcase.CreateRandomShowcaseMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('showcase-0001')
.with_description(None)
.with_metadata(None)
.with_maximum_number_of_choice(2)
.with_display_items([
showcase.RandomDisplayItemModel()
.with_name('display-item-0001')
.with_consume_actions([
showcase.ConsumeAction()
.with_action('Gs2Inventory:ConsumeItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0001", "userId": "#{userId}", "consumeCount": 10}'),
])
.with_acquire_actions([
showcase.AcquireAction()
.with_action('Gs2Inventory:AcquireItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0002", "userId": "#{userId}", "acquireCount": 1}'),
])
.with_stock(1)
.with_weight(1),
showcase.RandomDisplayItemModel()
.with_name('display-item-0002')
.with_consume_actions([
showcase.ConsumeAction()
.with_action('Gs2Inventory:ConsumeItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0001", "userId": "#{userId}", "consumeCount": 10}'),
])
.with_acquire_actions([
showcase.AcquireAction()
.with_action('Gs2Inventory:AcquireItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0002", "userId": "#{userId}", "acquireCount": 1}'),
])
.with_stock(2)
.with_weight(2),
showcase.RandomDisplayItemModel()
.with_name('display-item-0003')
.with_consume_actions([
showcase.ConsumeAction()
.with_action('Gs2Inventory:ConsumeItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0001", "userId": "#{userId}", "consumeCount": 10}'),
])
.with_acquire_actions([
showcase.AcquireAction()
.with_action('Gs2Inventory:AcquireItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0002", "userId": "#{userId}", "acquireCount": 1}'),
])
.with_stock(3)
.with_weight(3),
])
.with_base_timestamp(1000)
.with_reset_interval_hours(6)
.with_sales_period_event_id('grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.create_random_showcase_master({
namespaceName="namespace-0001",
name="showcase-0001",
description=nil,
metadata=nil,
maximumNumberOfChoice=2,
displayItems={
{
name="display-item-0001",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=1,
weight=1,
},
{
name="display-item-0002",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=2,
weight=2,
},
{
name="display-item-0003",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=3,
weight=3,
}
},
baseTimestamp=1000,
resetIntervalHours=6,
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-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('showcase')
api_result_handler = client.create_random_showcase_master_async({
namespaceName="namespace-0001",
name="showcase-0001",
description=nil,
metadata=nil,
maximumNumberOfChoice=2,
displayItems={
{
name="display-item-0001",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=1,
weight=1,
},
{
name="display-item-0002",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=2,
weight=2,
},
{
name="display-item-0003",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=3,
weight=3,
}
},
baseTimestamp=1000,
resetIntervalHours=6,
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-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;
```
---
### getRandomShowcaseMaster
ランダム陳列棚マスターを取得
商品プール、最大表示数、ローテーションタイミング設定、販売期間イベント設定を含む、指定されたランダム陳列棚マスターを取得します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomShowcaseMaster](#randomshowcasemaster) | ランダム陳列棚マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.GetRandomShowcaseMaster(
&showcase.GetRandomShowcaseMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\GetRandomShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->getRandomShowcaseMaster(
(new GetRandomShowcaseMasterRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.GetRandomShowcaseMasterRequest;
import io.gs2.showcase.result.GetRandomShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
GetRandomShowcaseMasterResult result = client.getRandomShowcaseMaster(
new GetRandomShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
);
RandomShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetRandomShowcaseMaster(
new Gs2.Gs2Showcase.Request.GetRandomShowcaseMasterRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.getRandomShowcaseMaster(
new Gs2Showcase.GetRandomShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.get_random_showcase_master(
showcase.GetRandomShowcaseMasterRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.get_random_showcase_master({
namespaceName="namespace-0001",
showcaseName="showcase-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('showcase')
api_result_handler = client.get_random_showcase_master_async({
namespaceName="namespace-0001",
showcaseName="showcase-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;
```
---
### updateRandomShowcaseMaster
ランダム陳列棚マスターを更新
指定されたランダム陳列棚マスターの説明、メタデータ、商品プール、最大表示数、ローテーションタイミング、販売期間イベントを更新します。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| description | string | | | | ~ 1024文字 | 説明文 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| maximumNumberOfChoice | int | | ✓| | 1 ~ 100 | 選出される商品の最大数
各ローテーション期間に商品プールからランダムに抽選される商品の数です。重み付きランダム選択で重複なく抽選されるため、1回のローテーションで同じ商品が2回表示されることはありません。 |
| displayItems | [List<RandomDisplayItemModel>](#randomdisplayitemmodel) | | ✓| | 1 ~ 100 items | 選出対象のランダム陳列商品リスト
商品がランダムに抽選される候補アイテムのプールです。各アイテムには選択確率を決定する重みと、ローテーション全体で表示可能な回数を制限する在庫数があります。 |
| baseTimestamp | long | | ✓| | | 陳列する商品を再抽選する基準時刻
ローテーション境界の計算に使用される基準タイムスタンプです。この基準時間から一定間隔（resetIntervalHours）ごとに商品の再抽選が行われます。過去の時刻を指定する必要があります。 |
| resetIntervalHours | int | | ✓| | 1 ~ 168 | 陳列する商品を再抽選する間隔（時）
各商品ローテーション間の時間数です。baseTimestamp を基準として間隔が経過すると、新しい乱数シードで陳列商品が再抽選されます。1〜168時間（1週間）の範囲で設定できます。 |
| salesPeriodEventId | string | | | | ~ 1024文字 | 陳列棚の販売期間を設定した GS2-Schedule のイベントGRN
このランダム陳列棚全体の販売期間を制御します。指定した場合、関連する GS2-Schedule のイベント期間中のみ陳列棚が利用可能になります。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomShowcaseMaster](#randomshowcasemaster) | 更新したランダム陳列棚マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.UpdateRandomShowcaseMaster(
&showcase.UpdateRandomShowcaseMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("SHOWCASE_0001"),
MaximumNumberOfChoice: pointy.Int32(1),
DisplayItems: []showcase.RandomDisplayItemModel{
showcase.RandomDisplayItemModel{
Name: pointy.String("display-item-1001"),
ConsumeActions: []showcase.ConsumeAction{
showcase.ConsumeAction{
Action: pointy.String("Gs2Inventory:ConsumeItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
},
},
AcquireActions: []showcase.AcquireAction{
showcase.AcquireAction{
Action: pointy.String("Gs2Inventory:AcquireItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
},
},
Stock: pointy.Int32(5),
Weight: pointy.Int32(10),
},
showcase.RandomDisplayItemModel{
Name: pointy.String("display-item-1002"),
ConsumeActions: []showcase.ConsumeAction{
showcase.ConsumeAction{
Action: pointy.String("Gs2Inventory:ConsumeItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
},
},
AcquireActions: []showcase.AcquireAction{
showcase.AcquireAction{
Action: pointy.String("Gs2Inventory:AcquireItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
},
},
Stock: pointy.Int32(10),
Weight: pointy.Int32(20),
},
showcase.RandomDisplayItemModel{
Name: pointy.String("display-item-1003"),
ConsumeActions: []showcase.ConsumeAction{
showcase.ConsumeAction{
Action: pointy.String("Gs2Inventory:ConsumeItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
},
},
AcquireActions: []showcase.AcquireAction{
showcase.AcquireAction{
Action: pointy.String("Gs2Inventory:AcquireItemSetByUserId"),
Request: pointy.String("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
},
},
Stock: pointy.Int32(15),
Weight: pointy.Int32(30),
},
},
BaseTimestamp: pointy.Int64(2000),
ResetIntervalHours: pointy.Int32(12),
SalesPeriodEventId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\UpdateRandomShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->updateRandomShowcaseMaster(
(new UpdateRandomShowcaseMasterRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-0001")
->withDescription("description1")
->withMetadata("SHOWCASE_0001")
->withMaximumNumberOfChoice(1)
->withDisplayItems([
(new \Gs2\Showcase\Model\RandomDisplayItemModel())
->withName("display-item-1001")
->withConsumeActions([
(new \Gs2\Showcase\Model\ConsumeAction())
->withAction("Gs2Inventory:ConsumeItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
->withAcquireActions([
(new \Gs2\Showcase\Model\AcquireAction())
->withAction("Gs2Inventory:AcquireItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
->withStock(5)
->withWeight(10),
(new \Gs2\Showcase\Model\RandomDisplayItemModel())
->withName("display-item-1002")
->withConsumeActions([
(new \Gs2\Showcase\Model\ConsumeAction())
->withAction("Gs2Inventory:ConsumeItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
->withAcquireActions([
(new \Gs2\Showcase\Model\AcquireAction())
->withAction("Gs2Inventory:AcquireItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
->withStock(10)
->withWeight(20),
(new \Gs2\Showcase\Model\RandomDisplayItemModel())
->withName("display-item-1003")
->withConsumeActions([
(new \Gs2\Showcase\Model\ConsumeAction())
->withAction("Gs2Inventory:ConsumeItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
->withAcquireActions([
(new \Gs2\Showcase\Model\AcquireAction())
->withAction("Gs2Inventory:AcquireItemSetByUserId")
->withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
->withStock(15)
->withWeight(30),
])
->withBaseTimestamp(2000)
->withResetIntervalHours(12)
->withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.UpdateRandomShowcaseMasterRequest;
import io.gs2.showcase.result.UpdateRandomShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
UpdateRandomShowcaseMasterResult result = client.updateRandomShowcaseMaster(
new UpdateRandomShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDescription("description1")
.withMetadata("SHOWCASE_0001")
.withMaximumNumberOfChoice(1)
.withDisplayItems(Arrays.asList(
new io.gs2.showcase.model.RandomDisplayItemModel()
.withName("display-item-1001")
.withConsumeActions(Arrays.asList(
new io.gs2.showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}")
))
.withAcquireActions(Arrays.asList(
new io.gs2.showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}")
))
.withStock(5)
.withWeight(10),
new io.gs2.showcase.model.RandomDisplayItemModel()
.withName("display-item-1002")
.withConsumeActions(Arrays.asList(
new io.gs2.showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}")
))
.withAcquireActions(Arrays.asList(
new io.gs2.showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}")
))
.withStock(10)
.withWeight(20),
new io.gs2.showcase.model.RandomDisplayItemModel()
.withName("display-item-1003")
.withConsumeActions(Arrays.asList(
new io.gs2.showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}")
))
.withAcquireActions(Arrays.asList(
new io.gs2.showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}")
))
.withStock(15)
.withWeight(30)
))
.withBaseTimestamp(2000L)
.withResetIntervalHours(12)
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
);
RandomShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateRandomShowcaseMaster(
new Gs2.Gs2Showcase.Request.UpdateRandomShowcaseMasterRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-0001")
.WithDescription("description1")
.WithMetadata("SHOWCASE_0001")
.WithMaximumNumberOfChoice(1)
.WithDisplayItems(new Gs2.Gs2Showcase.Model.RandomDisplayItemModel[] {
new Gs2.Gs2Showcase.Model.RandomDisplayItemModel()
.WithName("display-item-1001")
.WithConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
new Gs2.Core.Model.ConsumeAction()
.WithAction("Gs2Inventory:ConsumeItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
})
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Inventory:AcquireItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
})
.WithStock(5)
.WithWeight(10),
new Gs2.Gs2Showcase.Model.RandomDisplayItemModel()
.WithName("display-item-1002")
.WithConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
new Gs2.Core.Model.ConsumeAction()
.WithAction("Gs2Inventory:ConsumeItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
})
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Inventory:AcquireItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
})
.WithStock(10)
.WithWeight(20),
new Gs2.Gs2Showcase.Model.RandomDisplayItemModel()
.WithName("display-item-1003")
.WithConsumeActions(new Gs2.Core.Model.ConsumeAction[] {
new Gs2.Core.Model.ConsumeAction()
.WithAction("Gs2Inventory:ConsumeItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
})
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Inventory:AcquireItemSetByUserId")
.WithRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
})
.WithStock(15)
.WithWeight(30),
})
.WithBaseTimestamp(2000L)
.WithResetIntervalHours(12)
.WithSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.updateRandomShowcaseMaster(
new Gs2Showcase.UpdateRandomShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
.withDescription("description1")
.withMetadata("SHOWCASE_0001")
.withMaximumNumberOfChoice(1)
.withDisplayItems([
new Gs2Showcase.model.RandomDisplayItemModel()
.withName("display-item-1001")
.withConsumeActions([
new Gs2Showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
.withAcquireActions([
new Gs2Showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
.withStock(5)
.withWeight(10),
new Gs2Showcase.model.RandomDisplayItemModel()
.withName("display-item-1002")
.withConsumeActions([
new Gs2Showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
.withAcquireActions([
new Gs2Showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
.withStock(10)
.withWeight(20),
new Gs2Showcase.model.RandomDisplayItemModel()
.withName("display-item-1003")
.withConsumeActions([
new Gs2Showcase.model.ConsumeAction()
.withAction("Gs2Inventory:ConsumeItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}"),
])
.withAcquireActions([
new Gs2Showcase.model.AcquireAction()
.withAction("Gs2Inventory:AcquireItemSetByUserId")
.withRequest("{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}"),
])
.withStock(15)
.withWeight(30),
])
.withBaseTimestamp(2000)
.withResetIntervalHours(12)
.withSalesPeriodEventId("grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.update_random_showcase_master(
showcase.UpdateRandomShowcaseMasterRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
.with_description('description1')
.with_metadata('SHOWCASE_0001')
.with_maximum_number_of_choice(1)
.with_display_items([
showcase.RandomDisplayItemModel()
.with_name('display-item-1001')
.with_consume_actions([
showcase.ConsumeAction()
.with_action('Gs2Inventory:ConsumeItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0001", "userId": "#{userId}", "consumeCount": 10}'),
])
.with_acquire_actions([
showcase.AcquireAction()
.with_action('Gs2Inventory:AcquireItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0002", "userId": "#{userId}", "acquireCount": 1}'),
])
.with_stock(5)
.with_weight(10),
showcase.RandomDisplayItemModel()
.with_name('display-item-1002')
.with_consume_actions([
showcase.ConsumeAction()
.with_action('Gs2Inventory:ConsumeItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0001", "userId": "#{userId}", "consumeCount": 10}'),
])
.with_acquire_actions([
showcase.AcquireAction()
.with_action('Gs2Inventory:AcquireItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0002", "userId": "#{userId}", "acquireCount": 1}'),
])
.with_stock(10)
.with_weight(20),
showcase.RandomDisplayItemModel()
.with_name('display-item-1003')
.with_consume_actions([
showcase.ConsumeAction()
.with_action('Gs2Inventory:ConsumeItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0001", "userId": "#{userId}", "consumeCount": 10}'),
])
.with_acquire_actions([
showcase.AcquireAction()
.with_action('Gs2Inventory:AcquireItemSetByUserId')
.with_request('{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0002", "userId": "#{userId}", "acquireCount": 1}'),
])
.with_stock(15)
.with_weight(30),
])
.with_base_timestamp(2000)
.with_reset_interval_hours(12)
.with_sales_period_event_id('grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.update_random_showcase_master({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
description="description1",
metadata="SHOWCASE_0001",
maximumNumberOfChoice=1,
displayItems={
{
name="display-item-1001",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=5,
weight=10,
},
{
name="display-item-1002",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=10,
weight=20,
},
{
name="display-item-1003",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=15,
weight=30,
}
},
baseTimestamp=2000,
resetIntervalHours=12,
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('showcase')
api_result_handler = client.update_random_showcase_master_async({
namespaceName="namespace-0001",
showcaseName="showcase-0001",
description="description1",
metadata="SHOWCASE_0001",
maximumNumberOfChoice=1,
displayItems={
{
name="display-item-1001",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=5,
weight=10,
},
{
name="display-item-1002",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=10,
weight=20,
},
{
name="display-item-1003",
consumeActions={
{
action="Gs2Inventory:ConsumeItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0001\", \"userId\": \"#{userId}\", \"consumeCount\": 10}",
}
},
acquireActions={
{
action="Gs2Inventory:AcquireItemSetByUserId",
request="{\"namespaceName\": \"namespace-0001\", \"inventoryName\": \"item\", \"itemName\": \"item-0002\", \"userId\": \"#{userId}\", \"acquireCount\": 1}",
}
},
stock=15,
weight=30,
}
},
baseTimestamp=2000,
resetIntervalHours=12,
salesPeriodEventId="grn:gs2:ap-northeast-1:YourOwnerId:schedule:schedule-0001:event:event-0002",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteRandomShowcaseMaster
ランダム陳列棚マスターを削除
指定されたランダム陳列棚マスターを削除します。これはマスター定義のみを削除し、現在アクティブなランダム陳列棚には影響しません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| showcaseName | string | | ✓| | ~ 128文字 | ランダム陳列棚名
ランダム陳列棚固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [RandomShowcaseMaster](#randomshowcasemaster) | 削除したランダム陳列棚マスター |
#### 実装例
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/showcase"
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 := showcase.Gs2ShowcaseRestClient{
Session: &session,
}
result, err := client.DeleteRandomShowcaseMaster(
&showcase.DeleteRandomShowcaseMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
ShowcaseName: pointy.String("showcase-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\Showcase\Gs2ShowcaseRestClient;
use Gs2\Showcase\Request\DeleteRandomShowcaseMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ShowcaseRestClient(
$session
);
try {
$result = $client->deleteRandomShowcaseMaster(
(new DeleteRandomShowcaseMasterRequest())
->withNamespaceName("namespace-0001")
->withShowcaseName("showcase-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.showcase.rest.Gs2ShowcaseRestClient;
import io.gs2.showcase.request.DeleteRandomShowcaseMasterRequest;
import io.gs2.showcase.result.DeleteRandomShowcaseMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ShowcaseRestClient client = new Gs2ShowcaseRestClient(session);
try {
DeleteRandomShowcaseMasterResult result = client.deleteRandomShowcaseMaster(
new DeleteRandomShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
);
RandomShowcaseMaster 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 Gs2ShowcaseRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteRandomShowcaseMaster(
new Gs2.Gs2Showcase.Request.DeleteRandomShowcaseMasterRequest()
.WithNamespaceName("namespace-0001")
.WithShowcaseName("showcase-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 Gs2Showcase from '@/gs2/showcase';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Showcase.Gs2ShowcaseRestClient(session);
try {
const result = await client.deleteRandomShowcaseMaster(
new Gs2Showcase.DeleteRandomShowcaseMasterRequest()
.withNamespaceName("namespace-0001")
.withShowcaseName("showcase-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import showcase
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = showcase.Gs2ShowcaseRestClient(session)
try:
result = client.delete_random_showcase_master(
showcase.DeleteRandomShowcaseMasterRequest()
.with_namespace_name('namespace-0001')
.with_showcase_name('showcase-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('showcase')
api_result = client.delete_random_showcase_master({
namespaceName="namespace-0001",
showcaseName="showcase-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('showcase')
api_result_handler = client.delete_random_showcase_master_async({
namespaceName="namespace-0001",
showcaseName="showcase-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;
```
---