NAV Navbar
Python Java GS2-Formation
 

GS2-Inventory

所持品の管理機能を提供します。

アイテムを入れるカバンのような存在をインベントリと呼びます。 インベントリにはキャパシティを設定でき、キャパシティは後で拡張することができます。 課金通貨を使ったり、クエストの報酬でキャパシティを拡張することができます。

アイテムには有効期限を設定できます。 有効期限の切れたアイテムは使用できなくなり、アイテムを使用する際には明示的に有効期限を指定しなければ有効期限の近いアイテムから消費されます。

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

モデル

Namespace

ネームスペース

ネームスペースには所持品モデル(デフォルトの所持数量上限・所持数量最大値などの情報)を最大50種類指定できます。 50種類超える見込みがある場合はネームスペースを所持品のカテゴリごとに分割することを事前に検討してください。

ネームスペースを分割することで生じるデメリットとして、特定のゲームプレイヤーに関する所持品の一覧を取得したり、所持品のマスターデータを取得する際にネームスペースを超えて同時に取得することはできないことがあります。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true カテゴリー名
description string false ネームスペースの説明
acquireScript ScriptSetting false アイテム入手したときに実行するスクリプト
overflowScript ScriptSetting false 入手上限に当たって入手できなかったときに実行するスクリプト
consumeScript ScriptSetting false アイテム消費するときに実行するスクリプト
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

InventoryModelMaster

インベントリモデルマスター

所持品を入れるカバンのような存在。 何種類のアイテムを入れられるか、キャパシティを決めることができます。 キャパシティは拡張が可能です。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
inventoryModelId string true インベントリモデルマスター
name string true インベントリの種類名
metadata string false インベントリの種類のメタデータ
description string false インベントリモデルマスターの説明
initialCapacity integer true インベントリの初期サイズ
maxCapacity integer true インベントリの最大サイズ
createdAt long true 作成日時
updatedAt long true 最終更新日時

InventoryModel

インベントリモデル

所持品を入れるカバンのような存在。 何種類のアイテムを入れられるか、キャパシティを決めることができます。 キャパシティは拡張が可能です。

パラメータ データ型 必須 説明
inventoryModelId string true インベントリモデルマスター
name string true インベントリの種類名
metadata string false インベントリの種類のメタデータ
initialCapacity integer true インベントリの初期サイズ
maxCapacity integer true インベントリの最大サイズ
itemModels list[ItemModel] false インベントリに格納可能なアイテムモデル一覧

ItemModelMaster

アイテムモデルマスター

アイテムの種類について定義したデータ。 アイテムのメタデータをはじめとして、最大所持可能数や表示順番を保持。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
itemModelId string true アイテムモデルマスター
inventoryName string true アイテムの種類名
name string true アイテムモデルの種類名
description string false アイテムモデルマスターの説明
metadata string false アイテムモデルの種類のメタデータ
stackingLimit long true スタック可能な最大数量
allowMultipleStacks boolean true スタック可能な最大数量を超えた時複数枠にアイテムを保管することを許すか
sortValue integer true 表示順番
createdAt long true 作成日時
updatedAt long true 最終更新日時

ItemModel

アイテムモデル

アイテムの種類について定義したデータ。 アイテムのメタデータをはじめとして、最大所持可能数や表示順番を保持。

パラメータ データ型 必須 説明
itemModelId string true アイテムモデルマスター
name string true アイテムモデルの種類名
metadata string false アイテムモデルの種類のメタデータ
stackingLimit long true スタック可能な最大数量
allowMultipleStacks boolean true スタック可能な最大数量を超えた時複数枠にアイテムを保管することを許すか
sortValue integer true 表示順番

CurrentItemModelMaster

現在有効な所持品マスター

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

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

Inventory

インベントリ

所持品を入れるカバンのような存在。 ゲームプレイヤーの持っているインベントリのサイズなどの情報を記録。

パラメータ データ型 必須 説明
inventoryId string true インベントリ
inventoryName string true インベントリモデル名
userId string false ユーザーID
currentInventoryCapacityUsage integer true 現在のインベントリのキャパシティ使用量
currentInventoryMaxCapacity integer true 現在のインベントリの最大キャパシティ
createdAt long true 作成日時
updatedAt long true 最終更新日時

ItemSet

有効期限ごとのアイテム所持数量

同一アイテムの中で異なる有効期限ごとに所持数量を格納したデータ

パラメータ データ型 必須 説明
itemSetId string true 有効期限ごとのアイテム所持数量
inventoryName string true インベントリの名前
userId string true ユーザーID
itemName string true アイテムマスターの名前
count long true 所持数量
sortValue integer true 表示順番
expiresAt long true 有効期限
createdAt long true 作成日時
updatedAt long 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 タグ名

ScriptSetting

スクリプト設定

パラメータ データ型 必須 説明
triggerScriptId string false 実行前に使用する GS2-Script のスクリプト のGRN
doneTriggerScriptId string false 完了時に使用する GS2-Script のスクリプト のGRN
doneTriggerQueueNamespaceId string false 完了時に使用する GS2-JobQueue のネームスペース のGRN

LogSetting

ロギング通知設定

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

初期化処理

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

import gs2_core_client.model.*
import gs2_inventory_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_inventory_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 = Gs2InventoryRestClient(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.inventory.rest.Gs2InventoryRestClient

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

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

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

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

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

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

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

import gs2_core_client.model.*
import gs2_inventory_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 = Gs2InventoryWebSocketClient(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.inventory.webSocket.Gs2InventoryWebSocketClient

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

acquireItemSetByStampSheet

同期処理

from gs2_inventory_client.request import AcquireItemSetByStampSheetRequest
from gs2_inventory_client.result import AcquireItemSetByStampSheetResult

result = client.acquire_item_set_by_stamp_sheet(
    AcquireItemSetByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.AcquireItemSetByStampSheetRequest
import io.gs2.inventory.result.AcquireItemSetByStampSheetResult

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

非同期処理

from gs2_inventory_client.request import AcquireItemSetByStampSheetRequest
from gs2_inventory_client.result import AcquireItemSetByStampSheetResult

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

result = client.acquire_item_set_by_stamp_sheet_async(
    AcquireItemSetByStampSheetRequest()\
    callback
)
import io.gs2.inventory.request.AcquireItemSetByStampSheetRequest
import io.gs2.inventory.result.AcquireItemSetByStampSheetResult

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

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

スタンプシートでアイテムをインベントリに追加

パラメータ データ型 必須 説明
stampSheet string true スタンプシート
keyId string true スタンプシートの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
items list[ItemSet] 加算後の有効期限ごとのアイテム所持数量のリスト
itemModel ItemModel アイテムモデル
inventory Inventory インベントリ
overflowCount long 所持数量の上限を超えて受け取れずに GS2-Inbox に転送したアイテムの数量

acquireItemSetByUserId

同期処理

from gs2_inventory_client.request import AcquireItemSetByUserIdRequest
from gs2_inventory_client.result import AcquireItemSetByUserIdResult

result = client.acquire_item_set_by_user_id(
    AcquireItemSetByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.AcquireItemSetByUserIdRequest
import io.gs2.inventory.result.AcquireItemSetByUserIdResult

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

非同期処理

from gs2_inventory_client.request import AcquireItemSetByUserIdRequest
from gs2_inventory_client.result import AcquireItemSetByUserIdResult

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

result = client.acquire_item_set_by_user_id_async(
    AcquireItemSetByUserIdRequest()\
    callback
)
import io.gs2.inventory.request.AcquireItemSetByUserIdRequest
import io.gs2.inventory.result.AcquireItemSetByUserIdResult

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

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

アイテムをインベントリに追加

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの種類名
itemName string true アイテムマスターの名前
userId string false ユーザーID
acquireCount long true 入手する量
expiresAt long false 有効期限
パラメータ データ型 説明
items list[ItemSet] 加算後の有効期限ごとのアイテム所持数量のリスト
itemModel ItemModel アイテムモデル
inventory Inventory インベントリ
overflowCount long 所持数量の上限を超えて受け取れずに GS2-Inbox に転送したアイテムの数量

addCapacityByStampSheet

同期処理

from gs2_inventory_client.request import AddCapacityByStampSheetRequest
from gs2_inventory_client.result import AddCapacityByStampSheetResult

result = client.add_capacity_by_stamp_sheet(
    AddCapacityByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.AddCapacityByStampSheetRequest
import io.gs2.inventory.result.AddCapacityByStampSheetResult

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

非同期処理

from gs2_inventory_client.request import AddCapacityByStampSheetRequest
from gs2_inventory_client.result import AddCapacityByStampSheetResult

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

result = client.add_capacity_by_stamp_sheet_async(
    AddCapacityByStampSheetRequest()\
    callback
)
import io.gs2.inventory.request.AddCapacityByStampSheetRequest
import io.gs2.inventory.result.AddCapacityByStampSheetResult

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

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

スタンプシートでキャパシティサイズを加算

パラメータ データ型 必須 説明
stampSheet string true スタンプシート
keyId string true スタンプシートの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Inventory キャパシティ加算後のインベントリ

addCapacityByUserId

同期処理

from gs2_inventory_client.request import AddCapacityByUserIdRequest
from gs2_inventory_client.result import AddCapacityByUserIdResult

result = client.add_capacity_by_user_id(
    AddCapacityByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.AddCapacityByUserIdRequest
import io.gs2.inventory.result.AddCapacityByUserIdResult

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

非同期処理

from gs2_inventory_client.request import AddCapacityByUserIdRequest
from gs2_inventory_client.result import AddCapacityByUserIdResult

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

result = client.add_capacity_by_user_id_async(
    AddCapacityByUserIdRequest()\
    callback
)
import io.gs2.inventory.request.AddCapacityByUserIdRequest
import io.gs2.inventory.result.AddCapacityByUserIdResult

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

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

キャパシティサイズを加算

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリモデル名
userId string false ユーザーID
addCapacityValue integer true 加算するキャパシティサイズ
パラメータ データ型 説明
item Inventory キャパシティ加算後のインベントリ

consumeItemSet

同期処理

from gs2_inventory_client.request import ConsumeItemSetRequest
from gs2_inventory_client.result import ConsumeItemSetResult

result = client.consume_item_set(
    ConsumeItemSetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.ConsumeItemSetRequest
import io.gs2.inventory.result.ConsumeItemSetResult

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

非同期処理

from gs2_inventory_client.request import ConsumeItemSetRequest
from gs2_inventory_client.result import ConsumeItemSetResult

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

result = client.consume_item_set_async(
    ConsumeItemSetRequest()\
    callback
)
import io.gs2.inventory.request.ConsumeItemSetRequest
import io.gs2.inventory.result.ConsumeItemSetResult

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

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

インベントリのアイテムを消費

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの名前
itemName string true アイテムマスターの名前
consumeCount long true 消費する量
expiresAt long false 有効期限
パラメータ データ型 説明
items list[ItemSet] 消費後の有効期限ごとのアイテム所持数量のリスト
itemModel ItemModel アイテムモデル
inventory Inventory インベントリ

consumeItemSetByStampTask

同期処理

from gs2_inventory_client.request import ConsumeItemSetByStampTaskRequest
from gs2_inventory_client.result import ConsumeItemSetByStampTaskResult

result = client.consume_item_set_by_stamp_task(
    ConsumeItemSetByStampTaskRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.ConsumeItemSetByStampTaskRequest
import io.gs2.inventory.result.ConsumeItemSetByStampTaskResult

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

非同期処理

from gs2_inventory_client.request import ConsumeItemSetByStampTaskRequest
from gs2_inventory_client.result import ConsumeItemSetByStampTaskResult

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

result = client.consume_item_set_by_stamp_task_async(
    ConsumeItemSetByStampTaskRequest()\
    callback
)
import io.gs2.inventory.request.ConsumeItemSetByStampTaskRequest
import io.gs2.inventory.result.ConsumeItemSetByStampTaskResult

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

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

スタンプシートでインベントリのアイテムを消費

パラメータ データ型 必須 説明
stampTask string true スタンプタスク
keyId string true スタンプタスクの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
items list[ItemSet] 消費後の有効期限ごとのアイテム所持数量のリスト
itemModel ItemModel アイテムモデル
inventory Inventory インベントリ
newContextStack string スタンプタスクの実行結果を記録したコンテキスト

consumeItemSetByUserId

同期処理

from gs2_inventory_client.request import ConsumeItemSetByUserIdRequest
from gs2_inventory_client.result import ConsumeItemSetByUserIdResult

result = client.consume_item_set_by_user_id(
    ConsumeItemSetByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.ConsumeItemSetByUserIdRequest
import io.gs2.inventory.result.ConsumeItemSetByUserIdResult

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

非同期処理

from gs2_inventory_client.request import ConsumeItemSetByUserIdRequest
from gs2_inventory_client.result import ConsumeItemSetByUserIdResult

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

result = client.consume_item_set_by_user_id_async(
    ConsumeItemSetByUserIdRequest()\
    callback
)
import io.gs2.inventory.request.ConsumeItemSetByUserIdRequest
import io.gs2.inventory.result.ConsumeItemSetByUserIdResult

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

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

インベントリのアイテムを消費

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの名前
userId string false ユーザーID
itemName string true アイテムマスターの名前
consumeCount long true 消費する量
expiresAt long false 有効期限
パラメータ データ型 説明
items list[ItemSet] 消費後の有効期限ごとのアイテム所持数量のリスト
itemModel ItemModel アイテムモデル
inventory Inventory インベントリ

createInventoryModelMaster

同期処理

from gs2_inventory_client.request import CreateInventoryModelMasterRequest
from gs2_inventory_client.result import CreateInventoryModelMasterResult

result = client.create_inventory_model_master(
    CreateInventoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('item')\
        .with_initial_capacity(50)\
        .with_max_capacity(100)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.CreateInventoryModelMasterRequest
import io.gs2.inventory.result.CreateInventoryModelMasterResult

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

非同期処理

from gs2_inventory_client.request import CreateInventoryModelMasterRequest
from gs2_inventory_client.result import CreateInventoryModelMasterResult

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

result = client.create_inventory_model_master_async(
    CreateInventoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('item')\
        .with_initial_capacity(50)\
        .with_max_capacity(100),
    callback
)
import io.gs2.inventory.request.CreateInventoryModelMasterRequest
import io.gs2.inventory.result.CreateInventoryModelMasterResult

result = client.createInventoryModelMaster(
    CreateInventoryModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("item")
        .withInitialCapacity(50)
        .withMaxCapacity(100),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Inventory::InventoryModelMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  InitialCapacity: Integer
  MaxCapacity: Integer

インベントリモデルマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
name string true インベントリの種類名
description string false インベントリモデルマスターの説明
metadata string false インベントリの種類のメタデータ
initialCapacity integer true インベントリの初期サイズ
maxCapacity integer true インベントリの最大サイズ
パラメータ データ型 説明
item InventoryModelMaster 作成したインベントリモデルマスター

createItemModelMaster

同期処理

from gs2_inventory_client.request import CreateItemModelMasterRequest
from gs2_inventory_client.result import CreateItemModelMasterResult

result = client.create_item_model_master(
    CreateItemModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')\
        .with_name('item-master-0001')\
        .with_stacking_limit(99)\
        .with_allow_multiple_stacks(False)\
        .with_sort_value(10)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.CreateItemModelMasterRequest
import io.gs2.inventory.result.CreateItemModelMasterResult

result = client.createItemModelMaster(
    CreateItemModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("item")
        .withName("item-master-0001")
        .withStackingLimit(99l)
        .withAllowMultipleStacks(false)
        .withSortValue(10)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inventory_client.request import CreateItemModelMasterRequest
from gs2_inventory_client.result import CreateItemModelMasterResult

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

result = client.create_item_model_master_async(
    CreateItemModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')\
        .with_name('item-master-0001')\
        .with_stacking_limit(99)\
        .with_allow_multiple_stacks(False)\
        .with_sort_value(10),
    callback
)
import io.gs2.inventory.request.CreateItemModelMasterRequest
import io.gs2.inventory.result.CreateItemModelMasterResult

result = client.createItemModelMaster(
    CreateItemModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("item")
        .withName("item-master-0001")
        .withStackingLimit(99l)
        .withAllowMultipleStacks(false)
        .withSortValue(10),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Inventory::ItemModelMaster
Properties:
  NamespaceName: String
  InventoryName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  StackingLimit: Long
  AllowMultipleStacks: Bool
  SortValue: Integer

アイテムモデルマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true アイテムの種類名
name string true アイテムモデルの種類名
description string false アイテムモデルマスターの説明
metadata string false アイテムモデルの種類のメタデータ
stackingLimit long true スタック可能な最大数量
allowMultipleStacks boolean true スタック可能な最大数量を超えた時複数枠にアイテムを保管することを許すか
sortValue integer true 表示順番
パラメータ データ型 説明
item ItemModelMaster 作成したアイテムモデルマスター

createNamespace

同期処理

from gs2_inventory_client.request import CreateNamespaceRequest
from gs2_inventory_client.result import CreateNamespaceResult

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

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

非同期処理

from gs2_inventory_client.request import CreateNamespaceRequest
from gs2_inventory_client.result import CreateNamespaceResult

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

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

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

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

パラメータ データ型 必須 説明
name string true カテゴリー名
description string false ネームスペースの説明
acquireScript ScriptSetting false アイテム入手したときに実行するスクリプト
overflowScript ScriptSetting false 入手上限に当たって入手できなかったときに実行するスクリプト
consumeScript ScriptSetting false アイテム消費するときに実行するスクリプト
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

deleteInventoryByUserId

同期処理

from gs2_inventory_client.request import DeleteInventoryByUserIdRequest
from gs2_inventory_client.result import DeleteInventoryByUserIdResult

result = client.delete_inventory_by_user_id(
    DeleteInventoryByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DeleteInventoryByUserIdRequest
import io.gs2.inventory.result.DeleteInventoryByUserIdResult

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

非同期処理

from gs2_inventory_client.request import DeleteInventoryByUserIdRequest
from gs2_inventory_client.result import DeleteInventoryByUserIdResult

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

result = client.delete_inventory_by_user_id_async(
    DeleteInventoryByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.inventory.request.DeleteInventoryByUserIdRequest
import io.gs2.inventory.result.DeleteInventoryByUserIdResult

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

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

インベントリを削除

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリモデル名
userId string false ユーザーID
パラメータ データ型 説明
item Inventory インベントリ

deleteInventoryModelMaster

同期処理

from gs2_inventory_client.request import DeleteInventoryModelMasterRequest
from gs2_inventory_client.result import DeleteInventoryModelMasterResult

result = client.delete_inventory_model_master(
    DeleteInventoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DeleteInventoryModelMasterRequest
import io.gs2.inventory.result.DeleteInventoryModelMasterResult

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

非同期処理

from gs2_inventory_client.request import DeleteInventoryModelMasterRequest
from gs2_inventory_client.result import DeleteInventoryModelMasterResult

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

result = client.delete_inventory_model_master_async(
    DeleteInventoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item'),
    callback
)
import io.gs2.inventory.request.DeleteInventoryModelMasterRequest
import io.gs2.inventory.result.DeleteInventoryModelMasterResult

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

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

インベントリモデルマスターを削除

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの種類名
パラメータ データ型 説明
item InventoryModelMaster 削除したインベントリモデルマスター

deleteItemModelMaster

同期処理

from gs2_inventory_client.request import DeleteItemModelMasterRequest
from gs2_inventory_client.result import DeleteItemModelMasterResult

result = client.delete_item_model_master(
    DeleteItemModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')\
        .with_item_name('item-master-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DeleteItemModelMasterRequest
import io.gs2.inventory.result.DeleteItemModelMasterResult

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

非同期処理

from gs2_inventory_client.request import DeleteItemModelMasterRequest
from gs2_inventory_client.result import DeleteItemModelMasterResult

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

result = client.delete_item_model_master_async(
    DeleteItemModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')\
        .with_item_name('item-master-0001'),
    callback
)
import io.gs2.inventory.request.DeleteItemModelMasterRequest
import io.gs2.inventory.result.DeleteItemModelMasterResult

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

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

アイテムモデルマスターを削除

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの種類名
itemName string true アイテムモデルの種類名
パラメータ データ型 説明
item ItemModelMaster 削除したアイテムモデルマスター

deleteItemSetByUserId

同期処理

from gs2_inventory_client.request import DeleteItemSetByUserIdRequest
from gs2_inventory_client.result import DeleteItemSetByUserIdResult

result = client.delete_item_set_by_user_id(
    DeleteItemSetByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')\
        .with_user_id('user-0001')\
        .with_item_name('item-0001')\
        .with_expires_at(0)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DeleteItemSetByUserIdRequest
import io.gs2.inventory.result.DeleteItemSetByUserIdResult

result = client.deleteItemSetByUserId(
    DeleteItemSetByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("inventory-0001")
        .withUserId("user-0001")
        .withItemName("item-0001")
        .withExpiresAt(0l)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inventory_client.request import DeleteItemSetByUserIdRequest
from gs2_inventory_client.result import DeleteItemSetByUserIdResult

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

result = client.delete_item_set_by_user_id_async(
    DeleteItemSetByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')\
        .with_user_id('user-0001')\
        .with_item_name('item-0001')\
        .with_expires_at(0),
    callback
)
import io.gs2.inventory.request.DeleteItemSetByUserIdRequest
import io.gs2.inventory.result.DeleteItemSetByUserIdResult

result = client.deleteItemSetByUserId(
    DeleteItemSetByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("inventory-0001")
        .withUserId("user-0001")
        .withItemName("item-0001")
        .withExpiresAt(0l),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

有効期限ごとのアイテム所持数量を削除

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの名前
userId string false ユーザーID
itemName string true アイテムマスターの名前
expiresAt long false 有効期限
パラメータ データ型 説明
items list[ItemSet] 削除した有効期限ごとのアイテム所持数量のリスト
itemModel ItemModel アイテムモデル
inventory Inventory インベントリ

deleteNamespace

同期処理

from gs2_inventory_client.request import DeleteNamespaceRequest
from gs2_inventory_client.result import DeleteNamespaceResult

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

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

非同期処理

from gs2_inventory_client.request import DeleteNamespaceRequest
from gs2_inventory_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.inventory.request.DeleteNamespaceRequest
import io.gs2.inventory.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 削除したネームスペース

describeInventories

同期処理

from gs2_inventory_client.request import DescribeInventoriesRequest
from gs2_inventory_client.result import DescribeInventoriesResult

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

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

非同期処理

from gs2_inventory_client.request import DescribeInventoriesRequest
from gs2_inventory_client.result import DescribeInventoriesResult

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

result = client.describe_inventories_async(
    DescribeInventoriesRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.inventory.request.DescribeInventoriesRequest
import io.gs2.inventory.result.DescribeInventoriesResult

result = client.describeInventories(
    DescribeInventoriesRequest()
        .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[Inventory] インベントリのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeInventoriesByUserId

同期処理

from gs2_inventory_client.request import DescribeInventoriesByUserIdRequest
from gs2_inventory_client.result import DescribeInventoriesByUserIdResult

result = client.describe_inventories_by_user_id(
    DescribeInventoriesByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DescribeInventoriesByUserIdRequest
import io.gs2.inventory.result.DescribeInventoriesByUserIdResult

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

非同期処理

from gs2_inventory_client.request import DescribeInventoriesByUserIdRequest
from gs2_inventory_client.result import DescribeInventoriesByUserIdResult

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

result = client.describe_inventories_by_user_id_async(
    DescribeInventoriesByUserIdRequest()\
    callback
)
import io.gs2.inventory.request.DescribeInventoriesByUserIdRequest
import io.gs2.inventory.result.DescribeInventoriesByUserIdResult

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

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

インベントリの一覧を取得

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

describeInventoryModelMasters

同期処理

from gs2_inventory_client.request import DescribeInventoryModelMastersRequest
from gs2_inventory_client.result import DescribeInventoryModelMastersResult

result = client.describe_inventory_model_masters(
    DescribeInventoryModelMastersRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DescribeInventoryModelMastersRequest
import io.gs2.inventory.result.DescribeInventoryModelMastersResult

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

非同期処理

from gs2_inventory_client.request import DescribeInventoryModelMastersRequest
from gs2_inventory_client.result import DescribeInventoryModelMastersResult

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

result = client.describe_inventory_model_masters_async(
    DescribeInventoryModelMastersRequest()\
    callback
)
import io.gs2.inventory.request.DescribeInventoryModelMastersRequest
import io.gs2.inventory.result.DescribeInventoryModelMastersResult

result = client.describeInventoryModelMasters(
    DescribeInventoryModelMastersRequest(),
    (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[InventoryModelMaster] インベントリモデルマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeInventoryModels

同期処理

from gs2_inventory_client.request import DescribeInventoryModelsRequest
from gs2_inventory_client.result import DescribeInventoryModelsResult

result = client.describe_inventory_models(
    DescribeInventoryModelsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DescribeInventoryModelsRequest
import io.gs2.inventory.result.DescribeInventoryModelsResult

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

非同期処理

from gs2_inventory_client.request import DescribeInventoryModelsRequest
from gs2_inventory_client.result import DescribeInventoryModelsResult

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

result = client.describe_inventory_models_async(
    DescribeInventoryModelsRequest()\
    callback
)
import io.gs2.inventory.request.DescribeInventoryModelsRequest
import io.gs2.inventory.result.DescribeInventoryModelsResult

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

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

インベントリモデルの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
パラメータ データ型 説明
items list[InventoryModel] インベントリモデルのリスト

describeItemModelMasters

同期処理

from gs2_inventory_client.request import DescribeItemModelMastersRequest
from gs2_inventory_client.result import DescribeItemModelMastersResult

result = client.describe_item_model_masters(
    DescribeItemModelMastersRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DescribeItemModelMastersRequest
import io.gs2.inventory.result.DescribeItemModelMastersResult

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

非同期処理

from gs2_inventory_client.request import DescribeItemModelMastersRequest
from gs2_inventory_client.result import DescribeItemModelMastersResult

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

result = client.describe_item_model_masters_async(
    DescribeItemModelMastersRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item'),
    callback
)
import io.gs2.inventory.request.DescribeItemModelMastersRequest
import io.gs2.inventory.result.DescribeItemModelMastersResult

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

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

アイテムモデルマスターの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true アイテムの種類名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[ItemModelMaster] アイテムモデルマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeItemModels

同期処理

from gs2_inventory_client.request import DescribeItemModelsRequest
from gs2_inventory_client.result import DescribeItemModelsResult

result = client.describe_item_models(
    DescribeItemModelsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DescribeItemModelsRequest
import io.gs2.inventory.result.DescribeItemModelsResult

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

非同期処理

from gs2_inventory_client.request import DescribeItemModelsRequest
from gs2_inventory_client.result import DescribeItemModelsResult

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

result = client.describe_item_models_async(
    DescribeItemModelsRequest()\
    callback
)
import io.gs2.inventory.request.DescribeItemModelsRequest
import io.gs2.inventory.result.DescribeItemModelsResult

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

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

Noneの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの種類名
パラメータ データ型 説明
items list[ItemModel] アイテムモデルのリスト

describeItemSets

同期処理

from gs2_inventory_client.request import DescribeItemSetsRequest
from gs2_inventory_client.result import DescribeItemSetsResult

result = client.describe_item_sets(
    DescribeItemSetsRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DescribeItemSetsRequest
import io.gs2.inventory.result.DescribeItemSetsResult

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

非同期処理

from gs2_inventory_client.request import DescribeItemSetsRequest
from gs2_inventory_client.result import DescribeItemSetsResult

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

result = client.describe_item_sets_async(
    DescribeItemSetsRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001'),
    callback
)
import io.gs2.inventory.request.DescribeItemSetsRequest
import io.gs2.inventory.result.DescribeItemSetsResult

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

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

有効期限ごとのアイテム所持数量の一覧を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの名前
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[ItemSet] 有効期限ごとのアイテム所持数量のリスト
nextPageToken string リストの続きを取得するためのページトークン

describeItemSetsByUserId

同期処理

from gs2_inventory_client.request import DescribeItemSetsByUserIdRequest
from gs2_inventory_client.result import DescribeItemSetsByUserIdResult

result = client.describe_item_sets_by_user_id(
    DescribeItemSetsByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.DescribeItemSetsByUserIdRequest
import io.gs2.inventory.result.DescribeItemSetsByUserIdResult

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

非同期処理

from gs2_inventory_client.request import DescribeItemSetsByUserIdRequest
from gs2_inventory_client.result import DescribeItemSetsByUserIdResult

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

result = client.describe_item_sets_by_user_id_async(
    DescribeItemSetsByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.inventory.request.DescribeItemSetsByUserIdRequest
import io.gs2.inventory.result.DescribeItemSetsByUserIdResult

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

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

有効期限ごとのアイテム所持数量の一覧を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの名前
userId string false ユーザーID
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[ItemSet] 有効期限ごとのアイテム所持数量のリスト
nextPageToken string リストの続きを取得するためのページトークン

describeNamespaces

同期処理

from gs2_inventory_client.request import DescribeNamespacesRequest
from gs2_inventory_client.result import DescribeNamespacesResult

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

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

非同期処理

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

exportMaster

同期処理

from gs2_inventory_client.request import ExportMasterRequest
from gs2_inventory_client.result import ExportMasterResult

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

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

非同期処理

from gs2_inventory_client.request import ExportMasterRequest
from gs2_inventory_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.inventory.request.ExportMasterRequest
import io.gs2.inventory.result.ExportMasterResult

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

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

現在有効な所持品マスターのマスターデータをエクスポートします

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
パラメータ データ型 説明
item CurrentItemModelMaster 現在有効な所持品マスター

getCurrentItemModelMaster

同期処理

from gs2_inventory_client.request import GetCurrentItemModelMasterRequest
from gs2_inventory_client.result import GetCurrentItemModelMasterResult

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

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

非同期処理

from gs2_inventory_client.request import GetCurrentItemModelMasterRequest
from gs2_inventory_client.result import GetCurrentItemModelMasterResult

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

result = client.get_current_item_model_master_async(
    GetCurrentItemModelMasterRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.inventory.request.GetCurrentItemModelMasterRequest
import io.gs2.inventory.result.GetCurrentItemModelMasterResult

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

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

現在有効な所持品マスターを取得します

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
パラメータ データ型 説明
item CurrentItemModelMaster 現在有効な所持品マスター

getInventory

同期処理

from gs2_inventory_client.request import GetInventoryRequest
from gs2_inventory_client.result import GetInventoryResult

result = client.get_inventory(
    GetInventoryRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.GetInventoryRequest
import io.gs2.inventory.result.GetInventoryResult

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

非同期処理

from gs2_inventory_client.request import GetInventoryRequest
from gs2_inventory_client.result import GetInventoryResult

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

result = client.get_inventory_async(
    GetInventoryRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001'),
    callback
)
import io.gs2.inventory.request.GetInventoryRequest
import io.gs2.inventory.result.GetInventoryResult

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

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

インベントリを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリモデル名
パラメータ データ型 説明
item Inventory インベントリ

getInventoryByUserId

同期処理

from gs2_inventory_client.request import GetInventoryByUserIdRequest
from gs2_inventory_client.result import GetInventoryByUserIdResult

result = client.get_inventory_by_user_id(
    GetInventoryByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_inventory_name('inventory-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.GetInventoryByUserIdRequest
import io.gs2.inventory.result.GetInventoryByUserIdResult

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

非同期処理

from gs2_inventory_client.request import GetInventoryByUserIdRequest
from gs2_inventory_client.result import GetInventoryByUserIdResult

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

result = client.get_inventory_by_user_id_async(
    GetInventoryByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_inventory_name('inventory-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.inventory.request.GetInventoryByUserIdRequest
import io.gs2.inventory.result.GetInventoryByUserIdResult

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

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

インベントリを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリモデル名
userId string false ユーザーID
パラメータ データ型 説明
item Inventory インベントリ

getInventoryModel

同期処理

from gs2_inventory_client.request import GetInventoryModelRequest
from gs2_inventory_client.result import GetInventoryModelResult

result = client.get_inventory_model(
    GetInventoryModelRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.GetInventoryModelRequest
import io.gs2.inventory.result.GetInventoryModelResult

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

非同期処理

from gs2_inventory_client.request import GetInventoryModelRequest
from gs2_inventory_client.result import GetInventoryModelResult

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

result = client.get_inventory_model_async(
    GetInventoryModelRequest()\
    callback
)
import io.gs2.inventory.request.GetInventoryModelRequest
import io.gs2.inventory.result.GetInventoryModelResult

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

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

インベントリモデルを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの種類名
パラメータ データ型 説明
item InventoryModel インベントリモデル

getInventoryModelMaster

同期処理

from gs2_inventory_client.request import GetInventoryModelMasterRequest
from gs2_inventory_client.result import GetInventoryModelMasterResult

result = client.get_inventory_model_master(
    GetInventoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.GetInventoryModelMasterRequest
import io.gs2.inventory.result.GetInventoryModelMasterResult

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

非同期処理

from gs2_inventory_client.request import GetInventoryModelMasterRequest
from gs2_inventory_client.result import GetInventoryModelMasterResult

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

result = client.get_inventory_model_master_async(
    GetInventoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item'),
    callback
)
import io.gs2.inventory.request.GetInventoryModelMasterRequest
import io.gs2.inventory.result.GetInventoryModelMasterResult

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

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

インベントリモデルマスターを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの種類名
パラメータ データ型 説明
item InventoryModelMaster インベントリモデルマスター

getItemModel

同期処理

from gs2_inventory_client.request import GetItemModelRequest
from gs2_inventory_client.result import GetItemModelResult

result = client.get_item_model(
    GetItemModelRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.GetItemModelRequest
import io.gs2.inventory.result.GetItemModelResult

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

非同期処理

from gs2_inventory_client.request import GetItemModelRequest
from gs2_inventory_client.result import GetItemModelResult

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

result = client.get_item_model_async(
    GetItemModelRequest()\
    callback
)
import io.gs2.inventory.request.GetItemModelRequest
import io.gs2.inventory.result.GetItemModelResult

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

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

Noneを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの種類名
itemName string true アイテムモデルの種類名
パラメータ データ型 説明
item ItemModel

getItemModelMaster

同期処理

from gs2_inventory_client.request import GetItemModelMasterRequest
from gs2_inventory_client.result import GetItemModelMasterResult

result = client.get_item_model_master(
    GetItemModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')\
        .with_item_name('item-master-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.GetItemModelMasterRequest
import io.gs2.inventory.result.GetItemModelMasterResult

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

非同期処理

from gs2_inventory_client.request import GetItemModelMasterRequest
from gs2_inventory_client.result import GetItemModelMasterResult

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

result = client.get_item_model_master_async(
    GetItemModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')\
        .with_item_name('item-master-0001'),
    callback
)
import io.gs2.inventory.request.GetItemModelMasterRequest
import io.gs2.inventory.result.GetItemModelMasterResult

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

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

アイテムモデルマスターを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの種類名
itemName string true アイテムモデルの種類名
パラメータ データ型 説明
item ItemModelMaster アイテムモデルマスター

getItemSet

同期処理

from gs2_inventory_client.request import GetItemSetRequest
from gs2_inventory_client.result import GetItemSetResult

result = client.get_item_set(
    GetItemSetRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')\
        .with_item_name('item-0001')\
        .with_expires_at(0)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.GetItemSetRequest
import io.gs2.inventory.result.GetItemSetResult

result = client.getItemSet(
    GetItemSetRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("inventory-0001")
        .withItemName("item-0001")
        .withExpiresAt(0l)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inventory_client.request import GetItemSetRequest
from gs2_inventory_client.result import GetItemSetResult

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

result = client.get_item_set_async(
    GetItemSetRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')\
        .with_item_name('item-0001')\
        .with_expires_at(0),
    callback
)
import io.gs2.inventory.request.GetItemSetRequest
import io.gs2.inventory.result.GetItemSetResult

result = client.getItemSet(
    GetItemSetRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("inventory-0001")
        .withItemName("item-0001")
        .withExpiresAt(0l),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

有効期限ごとのアイテム所持数量を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの名前
itemName string true アイテムマスターの名前
expiresAt long false 有効期限
パラメータ データ型 説明
items list[ItemSet] 有効期限毎の{model_name}
itemModel ItemModel アイテムモデル
inventory Inventory インベントリ

getItemSetByUserId

同期処理

from gs2_inventory_client.request import GetItemSetByUserIdRequest
from gs2_inventory_client.result import GetItemSetByUserIdResult

result = client.get_item_set_by_user_id(
    GetItemSetByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')\
        .with_user_id('user-0001')\
        .with_item_name('item-0001')\
        .with_expires_at(100000)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.GetItemSetByUserIdRequest
import io.gs2.inventory.result.GetItemSetByUserIdResult

result = client.getItemSetByUserId(
    GetItemSetByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("inventory-0001")
        .withUserId("user-0001")
        .withItemName("item-0001")
        .withExpiresAt(100000l)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inventory_client.request import GetItemSetByUserIdRequest
from gs2_inventory_client.result import GetItemSetByUserIdResult

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

result = client.get_item_set_by_user_id_async(
    GetItemSetByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('inventory-0001')\
        .with_user_id('user-0001')\
        .with_item_name('item-0001')\
        .with_expires_at(100000),
    callback
)
import io.gs2.inventory.request.GetItemSetByUserIdRequest
import io.gs2.inventory.result.GetItemSetByUserIdResult

result = client.getItemSetByUserId(
    GetItemSetByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("inventory-0001")
        .withUserId("user-0001")
        .withItemName("item-0001")
        .withExpiresAt(100000l),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

有効期限ごとのアイテム所持数量を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの名前
userId string false ユーザーID
itemName string true アイテムマスターの名前
expiresAt long false 有効期限
パラメータ データ型 説明
items list[ItemSet] 有効期限毎の{model_name}
itemModel ItemModel アイテムモデル
inventory Inventory インベントリ

getItemWithSignature

同期処理

from gs2_inventory_client.request import GetItemWithSignatureRequest
from gs2_inventory_client.result import GetItemWithSignatureResult

result = client.get_item_with_signature(
    GetItemWithSignatureRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.GetItemWithSignatureRequest
import io.gs2.inventory.result.GetItemWithSignatureResult

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

非同期処理

from gs2_inventory_client.request import GetItemWithSignatureRequest
from gs2_inventory_client.result import GetItemWithSignatureResult

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

result = client.get_item_with_signature_async(
    GetItemWithSignatureRequest()\
    callback
)
import io.gs2.inventory.request.GetItemWithSignatureRequest
import io.gs2.inventory.result.GetItemWithSignatureResult

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

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

有効期限ごとのアイテム所持数量を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの名前
itemName string true アイテムマスターの名前
expiresAt long false 有効期限
keyId string true 署名の発行に使用する暗号鍵 のGRN
パラメータ データ型 説明
items list[ItemSet] 有効期限毎の{model_name}
itemModel ItemModel アイテムモデル
inventory Inventory インベントリ
body string 署名対象のアイテムセット情報
signature string 署名

getItemWithSignatureByUserId

同期処理

from gs2_inventory_client.request import GetItemWithSignatureByUserIdRequest
from gs2_inventory_client.result import GetItemWithSignatureByUserIdResult

result = client.get_item_with_signature_by_user_id(
    GetItemWithSignatureByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.GetItemWithSignatureByUserIdRequest
import io.gs2.inventory.result.GetItemWithSignatureByUserIdResult

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

非同期処理

from gs2_inventory_client.request import GetItemWithSignatureByUserIdRequest
from gs2_inventory_client.result import GetItemWithSignatureByUserIdResult

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

result = client.get_item_with_signature_by_user_id_async(
    GetItemWithSignatureByUserIdRequest()\
    callback
)
import io.gs2.inventory.request.GetItemWithSignatureByUserIdRequest
import io.gs2.inventory.result.GetItemWithSignatureByUserIdResult

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

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

有効期限ごとのアイテム所持数量を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの名前
userId string false ユーザーID
itemName string true アイテムマスターの名前
expiresAt long false 有効期限
keyId string true 署名の発行に使用する暗号鍵 のGRN
パラメータ データ型 説明
items list[ItemSet] 有効期限毎の{model_name}
itemModel ItemModel アイテムモデル
inventory Inventory インベントリ
body string 署名対象のアイテムセット情報
signature string 署名

getNamespace

同期処理

from gs2_inventory_client.request import GetNamespaceRequest
from gs2_inventory_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_inventory_client.request import GetNamespaceRequest
from gs2_inventory_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.inventory.request.GetNamespaceRequest
import io.gs2.inventory.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_inventory_client.request import GetNamespaceStatusRequest
from gs2_inventory_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_inventory_client.request import GetNamespaceStatusRequest
from gs2_inventory_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.inventory.request.GetNamespaceStatusRequest
import io.gs2.inventory.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

setCapacityByStampSheet

同期処理

from gs2_inventory_client.request import SetCapacityByStampSheetRequest
from gs2_inventory_client.result import SetCapacityByStampSheetResult

result = client.set_capacity_by_stamp_sheet(
    SetCapacityByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.SetCapacityByStampSheetRequest
import io.gs2.inventory.result.SetCapacityByStampSheetResult

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

非同期処理

from gs2_inventory_client.request import SetCapacityByStampSheetRequest
from gs2_inventory_client.result import SetCapacityByStampSheetResult

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

result = client.set_capacity_by_stamp_sheet_async(
    SetCapacityByStampSheetRequest()\
    callback
)
import io.gs2.inventory.request.SetCapacityByStampSheetRequest
import io.gs2.inventory.result.SetCapacityByStampSheetResult

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

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

スタンプシートでキャパシティサイズを設定

パラメータ データ型 必須 説明
stampSheet string true スタンプシート
keyId string true スタンプシートの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Inventory 更新後のインベントリ

setCapacityByUserId

同期処理

from gs2_inventory_client.request import SetCapacityByUserIdRequest
from gs2_inventory_client.result import SetCapacityByUserIdResult

result = client.set_capacity_by_user_id(
    SetCapacityByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.SetCapacityByUserIdRequest
import io.gs2.inventory.result.SetCapacityByUserIdResult

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

非同期処理

from gs2_inventory_client.request import SetCapacityByUserIdRequest
from gs2_inventory_client.result import SetCapacityByUserIdResult

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

result = client.set_capacity_by_user_id_async(
    SetCapacityByUserIdRequest()\
    callback
)
import io.gs2.inventory.request.SetCapacityByUserIdRequest
import io.gs2.inventory.result.SetCapacityByUserIdResult

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

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

キャパシティサイズを設定

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリモデル名
userId string false ユーザーID
newCapacityValue integer true 現在のインベントリの最大キャパシティ
パラメータ データ型 説明
item Inventory 更新後のインベントリ

updateCurrentItemModelMaster

同期処理

from gs2_inventory_client.request import UpdateCurrentItemModelMasterRequest
from gs2_inventory_client.result import UpdateCurrentItemModelMasterResult

result = client.update_current_item_model_master(
    UpdateCurrentItemModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-02-05",\n  "inventoryModels": [\n    {\n      "name": "item",\n      "metadata": "INVENTORY_ITEM",\n      "initialCapacity": 100,\n      "maxCapacity": 999,\n      "itemModels": [\n        {\n          "name": "item-0001",\n          "metadata": "ITEM_0001",\n          "stackingLimit": 99,\n          "allowMultipleStacks": false,\n          "sortValue": 1\n        },\n        {\n          "name": "item-0002",\n          "metadata": "ITEM_0002",\n          "stackingLimit": 49,\n          "allowMultipleStacks": true,\n          "sortValue": 2\n        },\n        {\n          "name": "item-0003",\n          "metadata": "ITEM_0003",\n          "stackingLimit": 9,\n          "allowMultipleStacks": false,\n          "sortValue": 3\n        }\n      ]\n    },\n    {\n      "name": "character",\n      "metadata": "INVENTORY_CHARACTER",\n      "initialCapacity": 50,\n      "maxCapacity": 99,\n      "itemModels": [\n        {\n          "name": "character-0001",\n          "metadata": "CHARACTER_0001",\n          "stackingLimit": 99,\n          "allowMultipleStacks": false,\n          "sortValue": 1\n        },\n        {\n          "name": "character-0002",\n          "metadata": "CHARACTER_0002",\n          "stackingLimit": 49,\n          "allowMultipleStacks": true,\n          "sortValue": 2\n        },\n        {\n          "name": "character-0003",\n          "metadata": "CHARACTER_0003",\n          "stackingLimit": 9,\n          "allowMultipleStacks": false,\n          "sortValue": 3\n        }\n      ]\n    }\n  ]\n}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.UpdateCurrentItemModelMasterRequest
import io.gs2.inventory.result.UpdateCurrentItemModelMasterResult

result = client.updateCurrentItemModelMaster(
    UpdateCurrentItemModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-02-05",\n  "inventoryModels": [\n    {\n      "name": "item",\n      "metadata": "INVENTORY_ITEM",\n      "initialCapacity": 100,\n      "maxCapacity": 999,\n      "itemModels": [\n        {\n          "name": "item-0001",\n          "metadata": "ITEM_0001",\n          "stackingLimit": 99,\n          "allowMultipleStacks": false,\n          "sortValue": 1\n        },\n        {\n          "name": "item-0002",\n          "metadata": "ITEM_0002",\n          "stackingLimit": 49,\n          "allowMultipleStacks": true,\n          "sortValue": 2\n        },\n        {\n          "name": "item-0003",\n          "metadata": "ITEM_0003",\n          "stackingLimit": 9,\n          "allowMultipleStacks": false,\n          "sortValue": 3\n        }\n      ]\n    },\n    {\n      "name": "character",\n      "metadata": "INVENTORY_CHARACTER",\n      "initialCapacity": 50,\n      "maxCapacity": 99,\n      "itemModels": [\n        {\n          "name": "character-0001",\n          "metadata": "CHARACTER_0001",\n          "stackingLimit": 99,\n          "allowMultipleStacks": false,\n          "sortValue": 1\n        },\n        {\n          "name": "character-0002",\n          "metadata": "CHARACTER_0002",\n          "stackingLimit": 49,\n          "allowMultipleStacks": true,\n          "sortValue": 2\n        },\n        {\n          "name": "character-0003",\n          "metadata": "CHARACTER_0003",\n          "stackingLimit": 9,\n          "allowMultipleStacks": false,\n          "sortValue": 3\n        }\n      ]\n    }\n  ]\n}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inventory_client.request import UpdateCurrentItemModelMasterRequest
from gs2_inventory_client.result import UpdateCurrentItemModelMasterResult

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

result = client.update_current_item_model_master_async(
    UpdateCurrentItemModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-02-05",\n  "inventoryModels": [\n    {\n      "name": "item",\n      "metadata": "INVENTORY_ITEM",\n      "initialCapacity": 100,\n      "maxCapacity": 999,\n      "itemModels": [\n        {\n          "name": "item-0001",\n          "metadata": "ITEM_0001",\n          "stackingLimit": 99,\n          "allowMultipleStacks": false,\n          "sortValue": 1\n        },\n        {\n          "name": "item-0002",\n          "metadata": "ITEM_0002",\n          "stackingLimit": 49,\n          "allowMultipleStacks": true,\n          "sortValue": 2\n        },\n        {\n          "name": "item-0003",\n          "metadata": "ITEM_0003",\n          "stackingLimit": 9,\n          "allowMultipleStacks": false,\n          "sortValue": 3\n        }\n      ]\n    },\n    {\n      "name": "character",\n      "metadata": "INVENTORY_CHARACTER",\n      "initialCapacity": 50,\n      "maxCapacity": 99,\n      "itemModels": [\n        {\n          "name": "character-0001",\n          "metadata": "CHARACTER_0001",\n          "stackingLimit": 99,\n          "allowMultipleStacks": false,\n          "sortValue": 1\n        },\n        {\n          "name": "character-0002",\n          "metadata": "CHARACTER_0002",\n          "stackingLimit": 49,\n          "allowMultipleStacks": true,\n          "sortValue": 2\n        },\n        {\n          "name": "character-0003",\n          "metadata": "CHARACTER_0003",\n          "stackingLimit": 9,\n          "allowMultipleStacks": false,\n          "sortValue": 3\n        }\n      ]\n    }\n  ]\n}'),
    callback
)
import io.gs2.inventory.request.UpdateCurrentItemModelMasterRequest
import io.gs2.inventory.result.UpdateCurrentItemModelMasterResult

result = client.updateCurrentItemModelMaster(
    UpdateCurrentItemModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-02-05",\n  "inventoryModels": [\n    {\n      "name": "item",\n      "metadata": "INVENTORY_ITEM",\n      "initialCapacity": 100,\n      "maxCapacity": 999,\n      "itemModels": [\n        {\n          "name": "item-0001",\n          "metadata": "ITEM_0001",\n          "stackingLimit": 99,\n          "allowMultipleStacks": false,\n          "sortValue": 1\n        },\n        {\n          "name": "item-0002",\n          "metadata": "ITEM_0002",\n          "stackingLimit": 49,\n          "allowMultipleStacks": true,\n          "sortValue": 2\n        },\n        {\n          "name": "item-0003",\n          "metadata": "ITEM_0003",\n          "stackingLimit": 9,\n          "allowMultipleStacks": false,\n          "sortValue": 3\n        }\n      ]\n    },\n    {\n      "name": "character",\n      "metadata": "INVENTORY_CHARACTER",\n      "initialCapacity": 50,\n      "maxCapacity": 99,\n      "itemModels": [\n        {\n          "name": "character-0001",\n          "metadata": "CHARACTER_0001",\n          "stackingLimit": 99,\n          "allowMultipleStacks": false,\n          "sortValue": 1\n        },\n        {\n          "name": "character-0002",\n          "metadata": "CHARACTER_0002",\n          "stackingLimit": 49,\n          "allowMultipleStacks": true,\n          "sortValue": 2\n        },\n        {\n          "name": "character-0003",\n          "metadata": "CHARACTER_0003",\n          "stackingLimit": 9,\n          "allowMultipleStacks": false,\n          "sortValue": 3\n        }\n      ]\n    }\n  ]\n}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Inventory::CurrentItemModelMaster
Properties:
  NamespaceName: String
  Settings: String

現在有効な所持品マスターを更新します

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
settings string true マスターデータ
パラメータ データ型 説明
item CurrentItemModelMaster 更新した現在有効な所持品マスター

updateCurrentItemModelMasterFromGitHub

同期処理

from gs2_inventory_client.request import UpdateCurrentItemModelMasterFromGitHubRequest
from gs2_inventory_client.result import UpdateCurrentItemModelMasterFromGitHubResult

result = client.update_current_item_model_master_from_git_hub(
    UpdateCurrentItemModelMasterFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.UpdateCurrentItemModelMasterFromGitHubRequest
import io.gs2.inventory.result.UpdateCurrentItemModelMasterFromGitHubResult

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

非同期処理

from gs2_inventory_client.request import UpdateCurrentItemModelMasterFromGitHubRequest
from gs2_inventory_client.result import UpdateCurrentItemModelMasterFromGitHubResult

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

result = client.update_current_item_model_master_from_git_hub_async(
    UpdateCurrentItemModelMasterFromGitHubRequest()\
    callback
)
import io.gs2.inventory.request.UpdateCurrentItemModelMasterFromGitHubRequest
import io.gs2.inventory.result.UpdateCurrentItemModelMasterFromGitHubResult

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

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

現在有効な所持品マスターを更新します

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
checkoutSetting GitHubCheckoutSetting true GitHubからマスターデータをチェックアウトしてくる設定
パラメータ データ型 説明
item CurrentItemModelMaster 更新した現在有効な所持品マスター

updateInventoryModelMaster

同期処理

from gs2_inventory_client.request import UpdateInventoryModelMasterRequest
from gs2_inventory_client.result import UpdateInventoryModelMasterResult

result = client.update_inventory_model_master(
    UpdateInventoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')\
        .with_description('description1')\
        .with_metadata('ITEM_INVENTORY_MASTER')\
        .with_initial_capacity(150)\
        .with_max_capacity(250)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.UpdateInventoryModelMasterRequest
import io.gs2.inventory.result.UpdateInventoryModelMasterResult

result = client.updateInventoryModelMaster(
    UpdateInventoryModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("item")
        .withDescription("description1")
        .withMetadata("ITEM_INVENTORY_MASTER")
        .withInitialCapacity(150)
        .withMaxCapacity(250)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inventory_client.request import UpdateInventoryModelMasterRequest
from gs2_inventory_client.result import UpdateInventoryModelMasterResult

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

result = client.update_inventory_model_master_async(
    UpdateInventoryModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')\
        .with_description('description1')\
        .with_metadata('ITEM_INVENTORY_MASTER')\
        .with_initial_capacity(150)\
        .with_max_capacity(250),
    callback
)
import io.gs2.inventory.request.UpdateInventoryModelMasterRequest
import io.gs2.inventory.result.UpdateInventoryModelMasterResult

result = client.updateInventoryModelMaster(
    UpdateInventoryModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("item")
        .withDescription("description1")
        .withMetadata("ITEM_INVENTORY_MASTER")
        .withInitialCapacity(150)
        .withMaxCapacity(250),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

インベントリモデルマスターを更新

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの種類名
description string false インベントリモデルマスターの説明
metadata string false インベントリの種類のメタデータ
initialCapacity integer true インベントリの初期サイズ
maxCapacity integer true インベントリの最大サイズ
パラメータ データ型 説明
item InventoryModelMaster 更新したインベントリモデルマスター

updateItemModelMaster

同期処理

from gs2_inventory_client.request import UpdateItemModelMasterRequest
from gs2_inventory_client.result import UpdateItemModelMasterResult

result = client.update_item_model_master(
    UpdateItemModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')\
        .with_item_name('item-master-0001')\
        .with_description('description1')\
        .with_metadata('ITEM_MASTER_0001')\
        .with_stacking_limit(49)\
        .with_allow_multiple_stacks(True)\
        .with_sort_value(30)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.UpdateItemModelMasterRequest
import io.gs2.inventory.result.UpdateItemModelMasterResult

result = client.updateItemModelMaster(
    UpdateItemModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("item")
        .withItemName("item-master-0001")
        .withDescription("description1")
        .withMetadata("ITEM_MASTER_0001")
        .withStackingLimit(49l)
        .withAllowMultipleStacks(true)
        .withSortValue(30)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inventory_client.request import UpdateItemModelMasterRequest
from gs2_inventory_client.result import UpdateItemModelMasterResult

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

result = client.update_item_model_master_async(
    UpdateItemModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_inventory_name('item')\
        .with_item_name('item-master-0001')\
        .with_description('description1')\
        .with_metadata('ITEM_MASTER_0001')\
        .with_stacking_limit(49)\
        .with_allow_multiple_stacks(True)\
        .with_sort_value(30),
    callback
)
import io.gs2.inventory.request.UpdateItemModelMasterRequest
import io.gs2.inventory.result.UpdateItemModelMasterResult

result = client.updateItemModelMaster(
    UpdateItemModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withInventoryName("item")
        .withItemName("item-master-0001")
        .withDescription("description1")
        .withMetadata("ITEM_MASTER_0001")
        .withStackingLimit(49l)
        .withAllowMultipleStacks(true)
        .withSortValue(30),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

アイテムモデルマスターを更新

パラメータ データ型 必須 説明
namespaceName string true カテゴリー名
inventoryName string true インベントリの種類名
itemName string true アイテムモデルの種類名
description string false アイテムモデルマスターの説明
metadata string false アイテムモデルの種類のメタデータ
stackingLimit long true スタック可能な最大数量
allowMultipleStacks boolean true スタック可能な最大数量を超えた時複数枠にアイテムを保管することを許すか
sortValue integer true 表示順番
パラメータ データ型 説明
item ItemModelMaster 更新したアイテムモデルマスター

updateNamespace

同期処理

from gs2_inventory_client.request import UpdateNamespaceRequest
from gs2_inventory_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_acquire_script(Object("ScriptSetting", {"triggerScriptId": 'script-1001', "doneTriggerScriptId": 'script-1002', "doneTriggerQueueNamespaceId": 'namespace-1001'}))\
        .with_overflow_script(Object("ScriptSetting", {"doneTriggerScriptId": 'script-1003', "doneTriggerQueueNamespaceId": 'script-1004'}))\
        .with_consume_script(Object("ScriptSetting", {"triggerScriptId": 'script-1005', "doneTriggerScriptId": 'script-1006', "doneTriggerQueueNamespaceId": 'namespace-1001'}))\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inventory.request.UpdateNamespaceRequest
import io.gs2.inventory.result.UpdateNamespaceResult

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

非同期処理

from gs2_inventory_client.request import UpdateNamespaceRequest
from gs2_inventory_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_acquire_script(Object("ScriptSetting", {"triggerScriptId": 'script-1001', "doneTriggerScriptId": 'script-1002', "doneTriggerQueueNamespaceId": 'namespace-1001'}))\
        .with_overflow_script(Object("ScriptSetting", {"doneTriggerScriptId": 'script-1003', "doneTriggerQueueNamespaceId": 'script-1004'}))\
        .with_consume_script(Object("ScriptSetting", {"triggerScriptId": 'script-1005', "doneTriggerScriptId": 'script-1006', "doneTriggerQueueNamespaceId": 'namespace-1001'}))\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.inventory.request.UpdateNamespaceRequest
import io.gs2.inventory.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withAcquireScript(Object("ScriptSetting", {"triggerScriptId": "script-1001", "doneTriggerScriptId": "script-1002", "doneTriggerQueueNamespaceId": "namespace-1001"}))
        .withOverflowScript(Object("ScriptSetting", {"doneTriggerScriptId": "script-1003", "doneTriggerQueueNamespaceId": "script-1004"}))
        .withConsumeScript(Object("ScriptSetting", {"triggerScriptId": "script-1005", "doneTriggerScriptId": "script-1006", "doneTriggerQueueNamespaceId": "namespace-1001"}))
        .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 ネームスペースの説明
acquireScript ScriptSetting false アイテム入手したときに実行するスクリプト
overflowScript ScriptSetting false 入手上限に当たって入手できなかったときに実行するスクリプト
consumeScript ScriptSetting false アイテム消費するときに実行するスクリプト
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

GS2-Script トリガーイベント

AcquireTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
inventory = args['inventory']  -- type: Inventory
item_sets = args['itemSets']  -- type: list[ItemSet]
acquire_count = args['acquireCount']  -- type: long

result = {
    permit=,  -- type: boolean
    overrideAcquireCount=  -- type: integer
}

アイテム入手時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
inventory Inventory インベントリ
itemSets list[ItemSet] 有効期限ごとのアイテム所持数量のリスト
acquireCount long None
パラメータ データ型 説明
permit boolean アイテム入手を許可するか
overrideAcquireCount integer 実際に適用する入手量

AcquireDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
old_inventory = args['oldInventory']  -- type: Inventory
old_item_sets = args['oldItemSets']  -- type: list[ItemSet]
new_inventory = args['newInventory']  -- type: Inventory
new_item_sets = args['newItemSets']  -- type: list[ItemSet]
acquire_count = args['acquireCount']  -- type: long

result = {
}

アイテム入手完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
oldInventory Inventory インベントリ
oldItemSets list[ItemSet] 有効期限ごとのアイテム所持数量のリスト
newInventory Inventory インベントリ
newItemSets list[ItemSet] 有効期限ごとのアイテム所持数量のリスト
acquireCount long None
パラメータ データ型 説明

OverflowDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
inventory = args['inventory']  -- type: Inventory
item_set = args['itemSet']  -- type: ItemSet
overflow_value = args['overflowValue']  -- type: long

result = {
}

入手上限に当たって入手できなかった数量を通知する完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
inventory Inventory インベントリ
itemSet ItemSet 有効期限ごとのアイテム所持数量
overflowValue long None
パラメータ データ型 説明

ConsumeTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
inventory = args['inventory']  -- type: Inventory
item_sets = args['itemSets']  -- type: list[ItemSet]
consume_count = args['consumeCount']  -- type: long

result = {
    permit=,  -- type: boolean
    overrideConsumeCount=  -- type: integer
}

アイテム消費時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
inventory Inventory インベントリ
itemSets list[ItemSet] 有効期限ごとのアイテム所持数量のリスト
consumeCount long None
パラメータ データ型 説明
permit boolean アイテム消費を許可するか
overrideConsumeCount integer 実際に適用する消費量

ConsumeDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
old_inventory = args['oldInventory']  -- type: Inventory
old_item_sets = args['oldItemSets']  -- type: list[ItemSet]
new_inventory = args['newInventory']  -- type: Inventory
new_item_sets = args['newItemSets']  -- type: list[ItemSet]
consume_count = args['consumeCount']  -- type: long

result = {
}

アイテム消費完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
oldInventory Inventory インベントリ
oldItemSets list[ItemSet] 有効期限ごとのアイテム所持数量のリスト
newInventory Inventory インベントリ
newItemSets list[ItemSet] 有効期限ごとのアイテム所持数量のリスト
consumeCount long None
パラメータ データ型 説明

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

CurrentItemModelMaster

{
  "version": "2019-02-05"
  "inventoryModels": [
    {
      "name": "[string] インベントリの種類名",
      "metadata": "[string] インベントリの種類のメタデータ",
      "initialCapacity": "[integer] インベントリの初期サイズ",
      "maxCapacity": "[integer] インベントリの最大サイズ",
      "itemModels": [
        {
          "name": "[string] アイテムモデルの種類名",
          "metadata": "[string] アイテムモデルの種類のメタデータ",
          "stackingLimit": "[long] スタック可能な最大数量",
          "allowMultipleStacks": "[boolean] スタック可能な最大数量を超えた時複数枠にアイテムを保管することを許すか",
          "sortValue": "[integer] 表示順番"
        }
      ]
    }
  ]
}

現在有効な所持品マスター

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

GS2-Inventory の制限・制約

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