NAV Navbar
Python Java GS2-Formation
 

GS2-Showcase

ゲーム内ストア機能を提供します。

販売する商品には対価と報酬を設定します。対価にも報酬にも複数のリソースを設定できます。

ステップガチャや、初回のみディスカウントといった仕組みを実現するために、商品グループという仕組みがあります。 商品グループは、商品ごとに優先度を付けて複数の商品をまとめる仕組みで、購入可能な条件を満たし、かつもっとも優先度の高い商品が陳列されます。

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

モデル

Namespace

ネームスペース

ネームスペースには陳列棚モデル(陳列棚のカテゴライズ、販売期間)を最大10種類指定できます。陳列棚モデルには最大100種類の商品を陳列できます。 陳列棚の種類が10種類超える見込みがある場合はネームスペースを陳列棚のカテゴリごとに分割することを事前に検討してください。

ネームスペースを分割することで生じるデメリットとして、陳列棚モデルのマスターデータを取得する際にネームスペースを超えて同時に取得することはできないことがあります。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
queueNamespaceId string false 購入処理をジョブとして追加するキューのネームスペース のGRN
keyId string true 購入処理のスタンプシートで使用する暗号鍵GRN
description string false ネームスペースの説明
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

SalesItemMaster

商品マスター

入手する商品とその対価を設定。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
salesItemId string true 商品マスター
name string true 商品名
description string false 商品マスターの説明
metadata string false 商品のメタデータ
consumeActions list[ConsumeAction] true 消費アクションリスト
acquireActions list[AcquireAction] true 入手アクションリスト
createdAt long true 作成日時
updatedAt long true 最終更新日時

SalesItemGroupMaster

商品グループマスター

複数の商品をグループ化し、優先度の高い商品から購入可能な商品が陳列されます。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
salesItemGroupId string true 商品グループマスター
name string true 商品名
description string false 商品グループマスターの説明
metadata string false 商品のメタデータ
salesItemNames list[string] true 商品グループに含める商品リスト
createdAt long true 作成日時
updatedAt long true 最終更新日時

ShowcaseMaster

陳列棚マスター

陳列棚に陳列する商品または商品グループを設定。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
showcaseId string true 陳列棚マスター
name string true 陳列棚名
description string false 陳列棚マスターの説明
metadata string false 商品のメタデータ
displayItems list[DisplayItemMaster] false 陳列する商品モデル一覧
salesPeriodEventId string false 販売期間とするイベントマスター のGRN
createdAt long true 作成日時
updatedAt long true 最終更新日時

CurrentShowcaseMaster

現在有効な陳列棚マスター

エクスポートしたマスターデータを、現在有効な陳列棚マスターとしてインポートして使用します。

パラメータ データ型 必須 説明
namespaceId string true 現在有効な陳列棚マスター
settings string true マスターデータ

ResponseCache

レスポンスキャッシュ

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

GitHubCheckoutSetting

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

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

LogSetting

ロギング通知設定

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

SalesItem

商品

入手する商品とその対価

パラメータ データ型 必須 説明
name string true 商品名
metadata string false 商品のメタデータ
consumeActions list[ConsumeAction] true 消費アクションリスト
acquireActions list[AcquireAction] true 入手アクションリスト

SalesItemGroup

商品グループ

複数の商品をグループ化し、優先度の高い商品から購入可能な商品が陳列されます。

パラメータ データ型 必須 説明
name string true 商品グループ名
metadata string false メタデータ
salesItems list[SalesItem] true 商品リスト

Showcase

陳列棚

陳列棚に陳列する商品または商品グループを設定。

パラメータ データ型 必須 説明
showcaseId string true 陳列棚
name string true 商品名
metadata string false 商品のメタデータ
displayItems list[DisplayItem] false インベントリに格納可能なアイテムモデル一覧
salesPeriodEventId string false 販売期間とするイベントマスター のGRN

DisplayItem

陳列された商品

パラメータ データ型 必須 説明
displayItemId string false 陳列商品ID
type string true 種類
salesItem SalesItem false 陳列する商品
salesItemGroup SalesItemGroup false 陳列する商品グループ
salesPeriodEventId string false 販売期間とするイベントマスター のGRN

Config

設定値

パラメータ データ型 必須 説明
key string false 名前
value string false

ConsumeAction

消費アクション

パラメータ データ型 必須 説明
action string true スタンプタスクで実行するアクションの種類
request string true 消費リクエストのJSON

AcquireAction

入手アクション

パラメータ データ型 必須 説明
action string true スタンプシートで実行するアクションの種類
request string true 入手リクエストのJSON

DisplayItemMaster

None

パラメータ データ型 必須 説明
displayItemId string false 陳列商品ID
type string true 種類
salesItemName string true 陳列する商品の名前
salesItemGroupName string true 陳列する商品グループの名前
salesPeriodEventId string false 販売期間とするイベントマスター のGRN

初期化処理

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

import gs2_core_client.model.*
import gs2_showcase_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_showcase_client.rest.*

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

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

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

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

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

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

import gs2_core_client.model.*
import gs2_showcase_client.web_socket.*

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

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

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

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

import gs2_core_client.model.*
import gs2_showcase_client.web_socket.*

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

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

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

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

buy

同期処理

from gs2_showcase_client.request import BuyRequest
from gs2_showcase_client.result import BuyResult

result = client.buy(
    BuyRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.BuyRequest
import io.gs2.showcase.result.BuyResult

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

非同期処理

from gs2_showcase_client.request import BuyRequest
from gs2_showcase_client.result import BuyResult

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

result = client.buy_async(
    BuyRequest()\
    callback
)
import io.gs2.showcase.request.BuyRequest
import io.gs2.showcase.result.BuyResult

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

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

陳列棚を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
showcaseName string true 商品名
displayItemId string true 陳列商品ID
config list[Config] false 設定値
パラメータ データ型 説明
item SalesItem 商品
stampSheet string 購入処理の実行に使用するスタンプシート

buyByUserId

同期処理

from gs2_showcase_client.request import BuyByUserIdRequest
from gs2_showcase_client.result import BuyByUserIdResult

result = client.buy_by_user_id(
    BuyByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.BuyByUserIdRequest
import io.gs2.showcase.result.BuyByUserIdResult

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

非同期処理

from gs2_showcase_client.request import BuyByUserIdRequest
from gs2_showcase_client.result import BuyByUserIdResult

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

result = client.buy_by_user_id_async(
    BuyByUserIdRequest()\
    callback
)
import io.gs2.showcase.request.BuyByUserIdRequest
import io.gs2.showcase.result.BuyByUserIdResult

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

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

ユーザIDを指定して陳列棚を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
showcaseName string true 商品名
displayItemId string true 陳列商品ID
userId string false ユーザーID
config list[Config] false 設定値
パラメータ データ型 説明
item SalesItem 商品
stampSheet string 購入処理の実行に使用するスタンプシート

createNamespace

同期処理

from gs2_showcase_client.request import CreateNamespaceRequest
from gs2_showcase_client.result import CreateNamespaceResult

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

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

非同期処理

from gs2_showcase_client.request import CreateNamespaceRequest
from gs2_showcase_client.result import CreateNamespaceResult

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

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

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

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

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false ネームスペースの説明
queueNamespaceId string false 購入処理をジョブとして追加するキューのネームスペース のGRN
keyId string true 購入処理のスタンプシートで使用する暗号鍵GRN
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

createSalesItemGroupMaster

同期処理

from gs2_showcase_client.request import CreateSalesItemGroupMasterRequest
from gs2_showcase_client.result import CreateSalesItemGroupMasterResult

result = client.create_sales_item_group_master(
    CreateSalesItemGroupMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('sales-item-group-0001')\
        .with_sales_item_names([
sales_item1['name'],    
sales_item2['name']
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.CreateSalesItemGroupMasterRequest
import io.gs2.showcase.result.CreateSalesItemGroupMasterResult

result = client.createSalesItemGroupMaster(
    CreateSalesItemGroupMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("sales-item-group-0001")
        .withSalesItemNames(new [] {
sales_item1.get'Name(), 
sales_item2.get'Name()
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_showcase_client.request import CreateSalesItemGroupMasterRequest
from gs2_showcase_client.result import CreateSalesItemGroupMasterResult

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

result = client.create_sales_item_group_master_async(
    CreateSalesItemGroupMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('sales-item-group-0001')\
        .with_sales_item_names([
sales_item1['name'],    
sales_item2['name']
]),
    callback
)
import io.gs2.showcase.request.CreateSalesItemGroupMasterRequest
import io.gs2.showcase.result.CreateSalesItemGroupMasterResult

result = client.createSalesItemGroupMaster(
    CreateSalesItemGroupMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("sales-item-group-0001")
        .withSalesItemNames(new [] {
sales_item1.get'Name(), 
sales_item2.get'Name()
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Showcase::SalesItemGroupMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  SalesItemNames:
    - String
    - String

商品グループマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true 商品名
description string false 商品グループマスターの説明
metadata string false 商品のメタデータ
salesItemNames list[string] true 商品グループに含める商品リスト
パラメータ データ型 説明
item SalesItemGroupMaster 作成した商品グループマスター

createSalesItemMaster

同期処理

from gs2_showcase_client.request import CreateSalesItemMasterRequest
from gs2_showcase_client.result import CreateSalesItemMasterResult

result = client.create_sales_item_master(
    CreateSalesItemMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('sales-item-0001')\
        .with_consume_actions([
Object("ConsumeAction", {"action": 'Gs2Money:WithdrawByUserId', "request": '{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'})
])\
        .with_acquire_actions([
Object("AcquireAction", {"action": 'Gs2Stamina:RecoverStaminaByUserId', "request": '{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'})
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.CreateSalesItemMasterRequest
import io.gs2.showcase.result.CreateSalesItemMasterResult

result = client.createSalesItemMaster(
    CreateSalesItemMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("sales-item-0001")
        .withConsumeActions(new [] {
Object("ConsumeAction", {"action": "Gs2Money:WithdrawByUserId", "request": "{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}"})
})
        .withAcquireActions(new [] {
Object("AcquireAction", {"action": "Gs2Stamina:RecoverStaminaByUserId", "request": "{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}"})
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_showcase_client.request import CreateSalesItemMasterRequest
from gs2_showcase_client.result import CreateSalesItemMasterResult

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

result = client.create_sales_item_master_async(
    CreateSalesItemMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('sales-item-0001')\
        .with_consume_actions([
Object("ConsumeAction", {"action": 'Gs2Money:WithdrawByUserId', "request": '{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'})
])\
        .with_acquire_actions([
Object("AcquireAction", {"action": 'Gs2Stamina:RecoverStaminaByUserId', "request": '{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}'})
]),
    callback
)
import io.gs2.showcase.request.CreateSalesItemMasterRequest
import io.gs2.showcase.result.CreateSalesItemMasterResult

result = client.createSalesItemMaster(
    CreateSalesItemMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("sales-item-0001")
        .withConsumeActions(new [] {
Object("ConsumeAction", {"action": "Gs2Money:WithdrawByUserId", "request": "{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}"})
})
        .withAcquireActions(new [] {
Object("AcquireAction", {"action": "Gs2Stamina:RecoverStaminaByUserId", "request": "{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 100, "paidOnly": false}"})
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Showcase::SalesItemMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  ConsumeActions:
    -
      Action: String
      Request: String
    -
      Action: String
      Request: String
  AcquireActions:
    -
      Action: String
      Request: String
    -
      Action: String
      Request: String

商品マスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true 商品名
description string false 商品マスターの説明
metadata string false 商品のメタデータ
consumeActions list[ConsumeAction] true 消費アクションリスト
acquireActions list[AcquireAction] true 入手アクションリスト
パラメータ データ型 説明
item SalesItemMaster 作成した商品マスター

createShowcaseMaster

同期処理

from gs2_showcase_client.request import CreateShowcaseMasterRequest
from gs2_showcase_client.result import CreateShowcaseMasterResult

result = client.create_showcase_master(
    CreateShowcaseMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('showcase-0001')\
        .with_display_items([
Object("DisplayItemMaster", {"type": 'salesItem', "salesItemName": sales_item1['name']}),   
Object("DisplayItemMaster", {"type": 'salesItemGroup', "salesItemGroupName": sales_item_group1['name'], "salesPeriodEventId": 'grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001'})
])\
        .with_sales_period_event_id('grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.CreateShowcaseMasterRequest
import io.gs2.showcase.result.CreateShowcaseMasterResult

result = client.createShowcaseMaster(
    CreateShowcaseMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("showcase-0001")
        .withDisplayItems(new [] {
Object("DisplayItemMaster", {"type": "salesItem", "salesItemName": sales_item1.get'Name()}),    
Object("DisplayItemMaster", {"type": "salesItemGroup", "salesItemGroupName": sales_item_group1.get'Name(), "salesPeriodEventId": "grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001"})
})
        .withSalesPeriodEventId("grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_showcase_client.request import CreateShowcaseMasterRequest
from gs2_showcase_client.result import CreateShowcaseMasterResult

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

result = client.create_showcase_master_async(
    CreateShowcaseMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('showcase-0001')\
        .with_display_items([
Object("DisplayItemMaster", {"type": 'salesItem', "salesItemName": sales_item1['name']}),   
Object("DisplayItemMaster", {"type": 'salesItemGroup', "salesItemGroupName": sales_item_group1['name'], "salesPeriodEventId": 'grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001'})
])\
        .with_sales_period_event_id('grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001'),
    callback
)
import io.gs2.showcase.request.CreateShowcaseMasterRequest
import io.gs2.showcase.result.CreateShowcaseMasterResult

result = client.createShowcaseMaster(
    CreateShowcaseMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("showcase-0001")
        .withDisplayItems(new [] {
Object("DisplayItemMaster", {"type": "salesItem", "salesItemName": sales_item1.get'Name()}),    
Object("DisplayItemMaster", {"type": "salesItemGroup", "salesItemGroupName": sales_item_group1.get'Name(), "salesPeriodEventId": "grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001"})
})
        .withSalesPeriodEventId("grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Showcase::ShowcaseMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  DisplayItems:
    -
      DisplayItemId: Optional[String]
      Type: String
      SalesItemName: String
      SalesItemGroupName: String
      SalesPeriodEventId: Optional[String]
    -
      DisplayItemId: Optional[String]
      Type: String
      SalesItemName: String
      SalesItemGroupName: String
      SalesPeriodEventId: Optional[String]
  SalesPeriodEventId: Optional[String]

陳列棚マスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true 陳列棚名
description string false 陳列棚マスターの説明
metadata string false 商品のメタデータ
displayItems list[DisplayItemMaster] false 陳列する商品モデル一覧
salesPeriodEventId string false 販売期間とするイベントマスター のGRN
パラメータ データ型 説明
item ShowcaseMaster 作成した陳列棚マスター

deleteNamespace

同期処理

from gs2_showcase_client.request import DeleteNamespaceRequest
from gs2_showcase_client.result import DeleteNamespaceResult

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

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

非同期処理

from gs2_showcase_client.request import DeleteNamespaceRequest
from gs2_showcase_client.result import DeleteNamespaceResult

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

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

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

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

ネームスペースを削除

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

deleteSalesItemGroupMaster

同期処理

from gs2_showcase_client.request import DeleteSalesItemGroupMasterRequest
from gs2_showcase_client.result import DeleteSalesItemGroupMasterResult

result = client.delete_sales_item_group_master(
    DeleteSalesItemGroupMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_sales_item_group_name('sales-item-group-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.DeleteSalesItemGroupMasterRequest
import io.gs2.showcase.result.DeleteSalesItemGroupMasterResult

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

非同期処理

from gs2_showcase_client.request import DeleteSalesItemGroupMasterRequest
from gs2_showcase_client.result import DeleteSalesItemGroupMasterResult

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

result = client.delete_sales_item_group_master_async(
    DeleteSalesItemGroupMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_sales_item_group_name('sales-item-group-0001'),
    callback
)
import io.gs2.showcase.request.DeleteSalesItemGroupMasterRequest
import io.gs2.showcase.result.DeleteSalesItemGroupMasterResult

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

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

商品グループマスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
salesItemGroupName string true 商品名
パラメータ データ型 説明
item SalesItemGroupMaster 削除した商品グループマスター

deleteSalesItemMaster

同期処理

from gs2_showcase_client.request import DeleteSalesItemMasterRequest
from gs2_showcase_client.result import DeleteSalesItemMasterResult

result = client.delete_sales_item_master(
    DeleteSalesItemMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_sales_item_name('sales-item-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.DeleteSalesItemMasterRequest
import io.gs2.showcase.result.DeleteSalesItemMasterResult

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

非同期処理

from gs2_showcase_client.request import DeleteSalesItemMasterRequest
from gs2_showcase_client.result import DeleteSalesItemMasterResult

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

result = client.delete_sales_item_master_async(
    DeleteSalesItemMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_sales_item_name('sales-item-0001'),
    callback
)
import io.gs2.showcase.request.DeleteSalesItemMasterRequest
import io.gs2.showcase.result.DeleteSalesItemMasterResult

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

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

商品マスターを削除

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

deleteShowcaseMaster

同期処理

from gs2_showcase_client.request import DeleteShowcaseMasterRequest
from gs2_showcase_client.result import DeleteShowcaseMasterResult

result = client.delete_showcase_master(
    DeleteShowcaseMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_showcase_name('showcase-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.DeleteShowcaseMasterRequest
import io.gs2.showcase.result.DeleteShowcaseMasterResult

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

非同期処理

from gs2_showcase_client.request import DeleteShowcaseMasterRequest
from gs2_showcase_client.result import DeleteShowcaseMasterResult

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

result = client.delete_showcase_master_async(
    DeleteShowcaseMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_showcase_name('showcase-0001'),
    callback
)
import io.gs2.showcase.request.DeleteShowcaseMasterRequest
import io.gs2.showcase.result.DeleteShowcaseMasterResult

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

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

陳列棚マスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
showcaseName string true 陳列棚名
パラメータ データ型 説明
item ShowcaseMaster 削除した陳列棚マスター

describeNamespaces

同期処理

from gs2_showcase_client.request import DescribeNamespacesRequest
from gs2_showcase_client.result import DescribeNamespacesResult

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

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

非同期処理

from gs2_showcase_client.request import DescribeNamespacesRequest
from gs2_showcase_client.result import DescribeNamespacesResult

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

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

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

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

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

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

describeSalesItemGroupMasters

同期処理

from gs2_showcase_client.request import DescribeSalesItemGroupMastersRequest
from gs2_showcase_client.result import DescribeSalesItemGroupMastersResult

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

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

非同期処理

from gs2_showcase_client.request import DescribeSalesItemGroupMastersRequest
from gs2_showcase_client.result import DescribeSalesItemGroupMastersResult

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

result = client.describe_sales_item_group_masters_async(
    DescribeSalesItemGroupMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.showcase.request.DescribeSalesItemGroupMastersRequest
import io.gs2.showcase.result.DescribeSalesItemGroupMastersResult

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

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

商品グループマスターの一覧を取得

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

describeSalesItemMasters

同期処理

from gs2_showcase_client.request import DescribeSalesItemMastersRequest
from gs2_showcase_client.result import DescribeSalesItemMastersResult

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

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

非同期処理

from gs2_showcase_client.request import DescribeSalesItemMastersRequest
from gs2_showcase_client.result import DescribeSalesItemMastersResult

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

result = client.describe_sales_item_masters_async(
    DescribeSalesItemMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.showcase.request.DescribeSalesItemMastersRequest
import io.gs2.showcase.result.DescribeSalesItemMastersResult

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

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

商品マスターの一覧を取得

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

describeShowcaseMasters

同期処理

from gs2_showcase_client.request import DescribeShowcaseMastersRequest
from gs2_showcase_client.result import DescribeShowcaseMastersResult

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

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

非同期処理

from gs2_showcase_client.request import DescribeShowcaseMastersRequest
from gs2_showcase_client.result import DescribeShowcaseMastersResult

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

result = client.describe_showcase_masters_async(
    DescribeShowcaseMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.showcase.request.DescribeShowcaseMastersRequest
import io.gs2.showcase.result.DescribeShowcaseMastersResult

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

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

陳列棚マスターの一覧を取得

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

describeShowcases

同期処理

from gs2_showcase_client.request import DescribeShowcasesRequest
from gs2_showcase_client.result import DescribeShowcasesResult

result = client.describe_showcases(
    DescribeShowcasesRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.DescribeShowcasesRequest
import io.gs2.showcase.result.DescribeShowcasesResult

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

非同期処理

from gs2_showcase_client.request import DescribeShowcasesRequest
from gs2_showcase_client.result import DescribeShowcasesResult

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

result = client.describe_showcases_async(
    DescribeShowcasesRequest()\
    callback
)
import io.gs2.showcase.request.DescribeShowcasesRequest
import io.gs2.showcase.result.DescribeShowcasesResult

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

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

陳列棚の一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[Showcase] 陳列棚のリスト

describeShowcasesByUserId

同期処理

from gs2_showcase_client.request import DescribeShowcasesByUserIdRequest
from gs2_showcase_client.result import DescribeShowcasesByUserIdResult

result = client.describe_showcases_by_user_id(
    DescribeShowcasesByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.DescribeShowcasesByUserIdRequest
import io.gs2.showcase.result.DescribeShowcasesByUserIdResult

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

非同期処理

from gs2_showcase_client.request import DescribeShowcasesByUserIdRequest
from gs2_showcase_client.result import DescribeShowcasesByUserIdResult

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

result = client.describe_showcases_by_user_id_async(
    DescribeShowcasesByUserIdRequest()\
    callback
)
import io.gs2.showcase.request.DescribeShowcasesByUserIdRequest
import io.gs2.showcase.result.DescribeShowcasesByUserIdResult

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

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

ユーザIDを指定して陳列棚の一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
パラメータ データ型 説明
items list[Showcase] 陳列棚のリスト

exportMaster

同期処理

from gs2_showcase_client.request import ExportMasterRequest
from gs2_showcase_client.result import ExportMasterResult

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

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

非同期処理

from gs2_showcase_client.request import ExportMasterRequest
from gs2_showcase_client.result import ExportMasterResult

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

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

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

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

現在有効な陳列棚マスターのマスターデータをエクスポートします

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentShowcaseMaster 現在有効な陳列棚マスター

getCurrentShowcaseMaster

同期処理

from gs2_showcase_client.request import GetCurrentShowcaseMasterRequest
from gs2_showcase_client.result import GetCurrentShowcaseMasterResult

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

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

非同期処理

from gs2_showcase_client.request import GetCurrentShowcaseMasterRequest
from gs2_showcase_client.result import GetCurrentShowcaseMasterResult

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

result = client.get_current_showcase_master_async(
    GetCurrentShowcaseMasterRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.showcase.request.GetCurrentShowcaseMasterRequest
import io.gs2.showcase.result.GetCurrentShowcaseMasterResult

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

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

現在有効な陳列棚マスターを取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentShowcaseMaster 現在有効な陳列棚マスター

getNamespace

同期処理

from gs2_showcase_client.request import GetNamespaceRequest
from gs2_showcase_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_showcase_client.request import GetNamespaceRequest
from gs2_showcase_client.result import GetNamespaceResult

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

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

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

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

ネームスペースを取得

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

getNamespaceStatus

同期処理

from gs2_showcase_client.request import GetNamespaceStatusRequest
from gs2_showcase_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_showcase_client.request import GetNamespaceStatusRequest
from gs2_showcase_client.result import GetNamespaceStatusResult

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

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

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

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

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

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

getSalesItemGroupMaster

同期処理

from gs2_showcase_client.request import GetSalesItemGroupMasterRequest
from gs2_showcase_client.result import GetSalesItemGroupMasterResult

result = client.get_sales_item_group_master(
    GetSalesItemGroupMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_sales_item_group_name('sales-item-group-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.GetSalesItemGroupMasterRequest
import io.gs2.showcase.result.GetSalesItemGroupMasterResult

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

非同期処理

from gs2_showcase_client.request import GetSalesItemGroupMasterRequest
from gs2_showcase_client.result import GetSalesItemGroupMasterResult

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

result = client.get_sales_item_group_master_async(
    GetSalesItemGroupMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_sales_item_group_name('sales-item-group-0001'),
    callback
)
import io.gs2.showcase.request.GetSalesItemGroupMasterRequest
import io.gs2.showcase.result.GetSalesItemGroupMasterResult

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

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

商品グループマスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
salesItemGroupName string true 商品名
パラメータ データ型 説明
item SalesItemGroupMaster 商品グループマスター

getSalesItemMaster

同期処理

from gs2_showcase_client.request import GetSalesItemMasterRequest
from gs2_showcase_client.result import GetSalesItemMasterResult

result = client.get_sales_item_master(
    GetSalesItemMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_sales_item_name('sales-item-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.GetSalesItemMasterRequest
import io.gs2.showcase.result.GetSalesItemMasterResult

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

非同期処理

from gs2_showcase_client.request import GetSalesItemMasterRequest
from gs2_showcase_client.result import GetSalesItemMasterResult

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

result = client.get_sales_item_master_async(
    GetSalesItemMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_sales_item_name('sales-item-0001'),
    callback
)
import io.gs2.showcase.request.GetSalesItemMasterRequest
import io.gs2.showcase.result.GetSalesItemMasterResult

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

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

商品マスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
salesItemName string true 商品名
パラメータ データ型 説明
item SalesItemMaster 商品マスター

getShowcase

同期処理

from gs2_showcase_client.request import GetShowcaseRequest
from gs2_showcase_client.result import GetShowcaseResult

result = client.get_showcase(
    GetShowcaseRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.GetShowcaseRequest
import io.gs2.showcase.result.GetShowcaseResult

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

非同期処理

from gs2_showcase_client.request import GetShowcaseRequest
from gs2_showcase_client.result import GetShowcaseResult

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

result = client.get_showcase_async(
    GetShowcaseRequest()\
    callback
)
import io.gs2.showcase.request.GetShowcaseRequest
import io.gs2.showcase.result.GetShowcaseResult

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

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

陳列棚を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
showcaseName string true 商品名
パラメータ データ型 説明
item Showcase 陳列棚

getShowcaseByUserId

同期処理

from gs2_showcase_client.request import GetShowcaseByUserIdRequest
from gs2_showcase_client.result import GetShowcaseByUserIdResult

result = client.get_showcase_by_user_id(
    GetShowcaseByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.GetShowcaseByUserIdRequest
import io.gs2.showcase.result.GetShowcaseByUserIdResult

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

非同期処理

from gs2_showcase_client.request import GetShowcaseByUserIdRequest
from gs2_showcase_client.result import GetShowcaseByUserIdResult

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

result = client.get_showcase_by_user_id_async(
    GetShowcaseByUserIdRequest()\
    callback
)
import io.gs2.showcase.request.GetShowcaseByUserIdRequest
import io.gs2.showcase.result.GetShowcaseByUserIdResult

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

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

ユーザIDを指定して陳列棚を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
showcaseName string true 商品名
userId string true ユーザーID
パラメータ データ型 説明
item Showcase 陳列棚

getShowcaseMaster

同期処理

from gs2_showcase_client.request import GetShowcaseMasterRequest
from gs2_showcase_client.result import GetShowcaseMasterResult

result = client.get_showcase_master(
    GetShowcaseMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_showcase_name('showcase-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.GetShowcaseMasterRequest
import io.gs2.showcase.result.GetShowcaseMasterResult

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

非同期処理

from gs2_showcase_client.request import GetShowcaseMasterRequest
from gs2_showcase_client.result import GetShowcaseMasterResult

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

result = client.get_showcase_master_async(
    GetShowcaseMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_showcase_name('showcase-0001'),
    callback
)
import io.gs2.showcase.request.GetShowcaseMasterRequest
import io.gs2.showcase.result.GetShowcaseMasterResult

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

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

陳列棚マスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
showcaseName string true 陳列棚名
パラメータ データ型 説明
item ShowcaseMaster 陳列棚マスター

updateCurrentShowcaseMaster

同期処理

from gs2_showcase_client.request import UpdateCurrentShowcaseMasterRequest
from gs2_showcase_client.result import UpdateCurrentShowcaseMasterResult

result = client.update_current_showcase_master(
    UpdateCurrentShowcaseMasterRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.UpdateCurrentShowcaseMasterRequest
import io.gs2.showcase.result.UpdateCurrentShowcaseMasterResult

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

非同期処理

from gs2_showcase_client.request import UpdateCurrentShowcaseMasterRequest
from gs2_showcase_client.result import UpdateCurrentShowcaseMasterResult

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

result = client.update_current_showcase_master_async(
    UpdateCurrentShowcaseMasterRequest()\
    callback
)
import io.gs2.showcase.request.UpdateCurrentShowcaseMasterRequest
import io.gs2.showcase.result.UpdateCurrentShowcaseMasterResult

result = client.updateCurrentShowcaseMaster(
    UpdateCurrentShowcaseMasterRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Showcase::CurrentShowcaseMaster
Properties:
  NamespaceName: String
  Settings: String

現在有効な陳列棚マスターを更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
settings string true マスターデータ
パラメータ データ型 説明
item CurrentShowcaseMaster 更新した現在有効な陳列棚マスター

updateCurrentShowcaseMasterFromGitHub

同期処理

from gs2_showcase_client.request import UpdateCurrentShowcaseMasterFromGitHubRequest
from gs2_showcase_client.result import UpdateCurrentShowcaseMasterFromGitHubResult

result = client.update_current_showcase_master_from_git_hub(
    UpdateCurrentShowcaseMasterFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.UpdateCurrentShowcaseMasterFromGitHubRequest
import io.gs2.showcase.result.UpdateCurrentShowcaseMasterFromGitHubResult

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

非同期処理

from gs2_showcase_client.request import UpdateCurrentShowcaseMasterFromGitHubRequest
from gs2_showcase_client.result import UpdateCurrentShowcaseMasterFromGitHubResult

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

result = client.update_current_showcase_master_from_git_hub_async(
    UpdateCurrentShowcaseMasterFromGitHubRequest()\
    callback
)
import io.gs2.showcase.request.UpdateCurrentShowcaseMasterFromGitHubRequest
import io.gs2.showcase.result.UpdateCurrentShowcaseMasterFromGitHubResult

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

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

現在有効な陳列棚マスターを更新します

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

updateNamespace

同期処理

from gs2_showcase_client.request import UpdateNamespaceRequest
from gs2_showcase_client.result import UpdateNamespaceResult

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

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

非同期処理

from gs2_showcase_client.request import UpdateNamespaceRequest
from gs2_showcase_client.result import UpdateNamespaceResult

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

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

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

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

ネームスペースを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
description string false ネームスペースの説明
queueNamespaceId string false 購入処理をジョブとして追加するキューのネームスペース のGRN
keyId string true 購入処理のスタンプシートで使用する暗号鍵GRN
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

updateSalesItemGroupMaster

同期処理

from gs2_showcase_client.request import UpdateSalesItemGroupMasterRequest
from gs2_showcase_client.result import UpdateSalesItemGroupMasterResult

result = client.update_sales_item_group_master(
    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([
sales_item1['name'],    
sales_item2['name'],    
sales_item3['name']
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.UpdateSalesItemGroupMasterRequest
import io.gs2.showcase.result.UpdateSalesItemGroupMasterResult

result = client.updateSalesItemGroupMaster(
    UpdateSalesItemGroupMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSalesItemGroupName("sales-item-group-0001")
        .withDescription("description1")
        .withMetadata("SALES_ITEM_GROUP_0001")
        .withSalesItemNames(new [] {
sales_item1.get'Name(), 
sales_item2.get'Name(), 
sales_item3.get'Name()
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_showcase_client.request import UpdateSalesItemGroupMasterRequest
from gs2_showcase_client.result import UpdateSalesItemGroupMasterResult

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

result = client.update_sales_item_group_master_async(
    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([
sales_item1['name'],    
sales_item2['name'],    
sales_item3['name']
]),
    callback
)
import io.gs2.showcase.request.UpdateSalesItemGroupMasterRequest
import io.gs2.showcase.result.UpdateSalesItemGroupMasterResult

result = client.updateSalesItemGroupMaster(
    UpdateSalesItemGroupMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSalesItemGroupName("sales-item-group-0001")
        .withDescription("description1")
        .withMetadata("SALES_ITEM_GROUP_0001")
        .withSalesItemNames(new [] {
sales_item1.get'Name(), 
sales_item2.get'Name(), 
sales_item3.get'Name()
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

商品グループマスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
salesItemGroupName string true 商品名
description string false 商品グループマスターの説明
metadata string false 商品のメタデータ
salesItemNames list[string] true 商品グループに含める商品リスト
パラメータ データ型 説明
item SalesItemGroupMaster 更新した商品グループマスター

updateSalesItemMaster

同期処理

from gs2_showcase_client.request import UpdateSalesItemMasterRequest
from gs2_showcase_client.result import UpdateSalesItemMasterResult

result = client.update_sales_item_master(
    UpdateSalesItemMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_sales_item_name('sales-item-0001')\
        .with_description('description1')\
        .with_metadata('SALES_ITEM_0001')\
        .with_consume_actions([
Object("ConsumeAction", {"action": 'Gs2Money:WithdrawByUserId', "request": '{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}'})
])\
        .with_acquire_actions([
Object("AcquireAction", {"action": 'Gs2Stamina:RecoverStaminaByUserId', "request": '{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}'})
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.UpdateSalesItemMasterRequest
import io.gs2.showcase.result.UpdateSalesItemMasterResult

result = client.updateSalesItemMaster(
    UpdateSalesItemMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSalesItemName("sales-item-0001")
        .withDescription("description1")
        .withMetadata("SALES_ITEM_0001")
        .withConsumeActions(new [] {
Object("ConsumeAction", {"action": "Gs2Money:WithdrawByUserId", "request": "{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}"})
})
        .withAcquireActions(new [] {
Object("AcquireAction", {"action": "Gs2Stamina:RecoverStaminaByUserId", "request": "{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}"})
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_showcase_client.request import UpdateSalesItemMasterRequest
from gs2_showcase_client.result import UpdateSalesItemMasterResult

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

result = client.update_sales_item_master_async(
    UpdateSalesItemMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_sales_item_name('sales-item-0001')\
        .with_description('description1')\
        .with_metadata('SALES_ITEM_0001')\
        .with_consume_actions([
Object("ConsumeAction", {"action": 'Gs2Money:WithdrawByUserId', "request": '{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}'})
])\
        .with_acquire_actions([
Object("AcquireAction", {"action": 'Gs2Stamina:RecoverStaminaByUserId', "request": '{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}'})
]),
    callback
)
import io.gs2.showcase.request.UpdateSalesItemMasterRequest
import io.gs2.showcase.result.UpdateSalesItemMasterResult

result = client.updateSalesItemMaster(
    UpdateSalesItemMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSalesItemName("sales-item-0001")
        .withDescription("description1")
        .withMetadata("SALES_ITEM_0001")
        .withConsumeActions(new [] {
Object("ConsumeAction", {"action": "Gs2Money:WithdrawByUserId", "request": "{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}"})
})
        .withAcquireActions(new [] {
Object("AcquireAction", {"action": "Gs2Stamina:RecoverStaminaByUserId", "request": "{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}"})
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

商品マスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
salesItemName string true 商品名
description string false 商品マスターの説明
metadata string false 商品のメタデータ
consumeActions list[ConsumeAction] true 消費アクションリスト
acquireActions list[AcquireAction] true 入手アクションリスト
パラメータ データ型 説明
item SalesItemMaster 更新した商品マスター

updateShowcaseMaster

同期処理

from gs2_showcase_client.request import UpdateShowcaseMasterRequest
from gs2_showcase_client.result import UpdateShowcaseMasterResult

result = client.update_showcase_master(
    UpdateShowcaseMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_showcase_name('showcase-0001')\
        .with_description('description1')\
        .with_metadata('SHOWCASE_0001')\
        .with_display_items([
Object("DisplayItemMaster", {"type": 'salesItem', "salesItemName": sales_item3['name']}),   
Object("DisplayItemMaster", {"type": 'salesItemGroup', "salesItemGroupName": sales_item_group1['name'], "salesPeriodEventId": 'grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001'})
])\
        .with_sales_period_event_id('grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.showcase.request.UpdateShowcaseMasterRequest
import io.gs2.showcase.result.UpdateShowcaseMasterResult

result = client.updateShowcaseMaster(
    UpdateShowcaseMasterRequest()
        .withNamespaceName("namespace-0001")
        .withShowcaseName("showcase-0001")
        .withDescription("description1")
        .withMetadata("SHOWCASE_0001")
        .withDisplayItems(new [] {
Object("DisplayItemMaster", {"type": "salesItem", "salesItemName": sales_item3.get'Name()}),    
Object("DisplayItemMaster", {"type": "salesItemGroup", "salesItemGroupName": sales_item_group1.get'Name(), "salesPeriodEventId": "grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001"})
})
        .withSalesPeriodEventId("grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_showcase_client.request import UpdateShowcaseMasterRequest
from gs2_showcase_client.result import UpdateShowcaseMasterResult

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

result = client.update_showcase_master_async(
    UpdateShowcaseMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_showcase_name('showcase-0001')\
        .with_description('description1')\
        .with_metadata('SHOWCASE_0001')\
        .with_display_items([
Object("DisplayItemMaster", {"type": 'salesItem', "salesItemName": sales_item3['name']}),   
Object("DisplayItemMaster", {"type": 'salesItemGroup', "salesItemGroupName": sales_item_group1['name'], "salesPeriodEventId": 'grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001'})
])\
        .with_sales_period_event_id('grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002'),
    callback
)
import io.gs2.showcase.request.UpdateShowcaseMasterRequest
import io.gs2.showcase.result.UpdateShowcaseMasterResult

result = client.updateShowcaseMaster(
    UpdateShowcaseMasterRequest()
        .withNamespaceName("namespace-0001")
        .withShowcaseName("showcase-0001")
        .withDescription("description1")
        .withMetadata("SHOWCASE_0001")
        .withDisplayItems(new [] {
Object("DisplayItemMaster", {"type": "salesItem", "salesItemName": sales_item3.get'Name()}),    
Object("DisplayItemMaster", {"type": "salesItemGroup", "salesItemGroupName": sales_item_group1.get'Name(), "salesPeriodEventId": "grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0001"})
})
        .withSalesPeriodEventId("grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

陳列棚マスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
showcaseName string true 陳列棚名
description string false 陳列棚マスターの説明
metadata string false 商品のメタデータ
displayItems list[DisplayItemMaster] false 陳列する商品モデル一覧
salesPeriodEventId string false 販売期間とするイベントマスター のGRN
パラメータ データ型 説明
item ShowcaseMaster 更新した陳列棚マスター

GS2-Script トリガーイベント

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

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

CurrentShowcaseMaster

{
  "version": "2019-04-04"
  "showcases": [
    {
      "name": "[string] 商品名",
      "metadata": "[string] 商品のメタデータ",
      "salesPeriodEventId": "[string] 販売期間とするイベントマスター のGRN",
      "displayItems": [
        {
          "type": "[string] 種類",
          "salesPeriodEventId": "[string] 販売期間とするイベントマスター のGRN",
          "salesItem": [
            {
              "name": "[string] 商品名",
              "metadata": "[string] 商品のメタデータ",
              "consumeActions": [
                {
                  "action": "[string] スタンプタスクで実行するアクションの種類",
                  "request": "[string] 消費リクエストのJSON"
                },
              ],
              "acquireActions": [
                {
                  "action": "[string] スタンプシートで実行するアクションの種類",
                  "request": "[string] 入手リクエストのJSON"
                }
              ]
            },
          ],
          "salesItemGroup": [
            {
              "name": "[string] 商品グループ名",
              "metadata": "[string] メタデータ",
              "salesItems": [
                {
                  "name": "[string] 商品名",
                  "metadata": "[string] 商品のメタデータ",
                  "consumeActions": [
                    {
                      "action": "[string] スタンプタスクで実行するアクションの種類",
                      "request": "[string] 消費リクエストのJSON"
                    },
                  ],
                  "acquireActions": [
                    {
                      "action": "[string] スタンプシートで実行するアクションの種類",
                      "request": "[string] 入手リクエストのJSON"
                    }
                  ]
                }
              ]
            }
          ]
        }
      ]
    }
  ]
}

現在有効な陳列棚マスター

エクスポートしたマスターデータを、現在有効な陳列棚マスターとしてインポートして使用します。

GS2-Showcase の制限・制約

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