NAV Navbar
Python Java GS2-Formation
 

GS2-Exchange

アイテムの売却価格や、レアリティが異なる進化素材間の交換レートなど、常設される交換処理を実現します。

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

モデル

Namespace

ネームスペース

ネームスペースには交換レートを最大10000種類指定できます。 10000種類超える見込みがある場合はネームスペースを交換するリソースのカテゴリごとに分割することを事前に検討してください。

ネームスペースを分割することで生じるデメリットは特にありません。

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

RateModel

交換レートモデル

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

RateModelMaster

交換レートマスター

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

Exchange

交換

パラメータ データ型 必須 説明

CurrentRateMaster

現在有効な交換レート設定

エクスポートしたマスターデータを、現在有効な交換レート設定としてインポートして使用します。

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

ResponseCache

レスポンスキャッシュ

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

Config

設定値

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

GitHubCheckoutSetting

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

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

LogSetting

ロギング通知設定

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

AcquireAction

入手アクション

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

ConsumeAction

消費アクション

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

初期化処理

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

import gs2_core_client.model.*
import gs2_exchange_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_exchange_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 = Gs2ExchangeRestClient(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.exchange.rest.Gs2ExchangeRestClient

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

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

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

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

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

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

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

import gs2_core_client.model.*
import gs2_exchange_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 = Gs2ExchangeWebSocketClient(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.exchange.webSocket.Gs2ExchangeWebSocketClient

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

createNamespace

同期処理

from gs2_exchange_client.request import CreateNamespaceRequest
from gs2_exchange_client.result import CreateNamespaceResult

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

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

非同期処理

from gs2_exchange_client.request import CreateNamespaceRequest
from gs2_exchange_client.result import CreateNamespaceResult

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

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

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

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

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

createRateModelMaster

同期処理

from gs2_exchange_client.request import CreateRateModelMasterRequest
from gs2_exchange_client.result import CreateRateModelMasterResult

result = client.create_rate_model_master(
    CreateRateModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('rate-0001')\
        .with_metadata('N2R')\
        .with_acquire_actions([
Object("AcquireAction", {"action": 'Gs2Inventory:AcquireItemSetByUserId', "request": '{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0002", "userId": "#{userId}", "acquireCount": 1}'})
])\
        .with_consume_actions([
Object("ConsumeAction", {"action": 'Gs2Inventory:ConsumeItemSetByUserId', "request": '{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0001", "userId": "#{userId}", "consumeCount": 10}'})
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.exchange.request.CreateRateModelMasterRequest
import io.gs2.exchange.result.CreateRateModelMasterResult

result = client.createRateModelMaster(
    CreateRateModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("rate-0001")
        .withMetadata("N2R")
        .withAcquireActions(new [] {
Object("AcquireAction", {"action": "Gs2Inventory:AcquireItemSetByUserId", "request": "{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0002", "userId": "#{userId}", "acquireCount": 1}"})
})
        .withConsumeActions(new [] {
Object("ConsumeAction", {"action": "Gs2Inventory:ConsumeItemSetByUserId", "request": "{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0001", "userId": "#{userId}", "consumeCount": 10}"})
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_exchange_client.request import CreateRateModelMasterRequest
from gs2_exchange_client.result import CreateRateModelMasterResult

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

result = client.create_rate_model_master_async(
    CreateRateModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('rate-0001')\
        .with_metadata('N2R')\
        .with_acquire_actions([
Object("AcquireAction", {"action": 'Gs2Inventory:AcquireItemSetByUserId', "request": '{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0002", "userId": "#{userId}", "acquireCount": 1}'})
])\
        .with_consume_actions([
Object("ConsumeAction", {"action": 'Gs2Inventory:ConsumeItemSetByUserId', "request": '{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0001", "userId": "#{userId}", "consumeCount": 10}'})
]),
    callback
)
import io.gs2.exchange.request.CreateRateModelMasterRequest
import io.gs2.exchange.result.CreateRateModelMasterResult

result = client.createRateModelMaster(
    CreateRateModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("rate-0001")
        .withMetadata("N2R")
        .withAcquireActions(new [] {
Object("AcquireAction", {"action": "Gs2Inventory:AcquireItemSetByUserId", "request": "{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0002", "userId": "#{userId}", "acquireCount": 1}"})
})
        .withConsumeActions(new [] {
Object("ConsumeAction", {"action": "Gs2Inventory:ConsumeItemSetByUserId", "request": "{"namespaceName": "namespace-0001", "inventoryName": "item", "itemName": "item-0001", "userId": "#{userId}", "consumeCount": 10}"})
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Exchange::RateModelMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  AcquireActions:
    -
      Action: String
      Request: String
    -
      Action: String
      Request: String
  ConsumeActions:
    -
      Action: String
      Request: String
    -
      Action: String
      Request: String

交換レートマスターを新規作成

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

deleteNamespace

同期処理

from gs2_exchange_client.request import DeleteNamespaceRequest
from gs2_exchange_client.result import DeleteNamespaceResult

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

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

非同期処理

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

deleteRateModelMaster

同期処理

from gs2_exchange_client.request import DeleteRateModelMasterRequest
from gs2_exchange_client.result import DeleteRateModelMasterResult

result = client.delete_rate_model_master(
    DeleteRateModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_rate_name('rate-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.exchange.request.DeleteRateModelMasterRequest
import io.gs2.exchange.result.DeleteRateModelMasterResult

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

非同期処理

from gs2_exchange_client.request import DeleteRateModelMasterRequest
from gs2_exchange_client.result import DeleteRateModelMasterResult

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

result = client.delete_rate_model_master_async(
    DeleteRateModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_rate_name('rate-0001'),
    callback
)
import io.gs2.exchange.request.DeleteRateModelMasterRequest
import io.gs2.exchange.result.DeleteRateModelMasterResult

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

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

交換レートマスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
rateName string true 交換レート名
パラメータ データ型 説明
item RateModelMaster 削除した交換レートマスター

describeNamespaces

同期処理

from gs2_exchange_client.request import DescribeNamespacesRequest
from gs2_exchange_client.result import DescribeNamespacesResult

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

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

非同期処理

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

describeRateModelMasters

同期処理

from gs2_exchange_client.request import DescribeRateModelMastersRequest
from gs2_exchange_client.result import DescribeRateModelMastersResult

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

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

非同期処理

from gs2_exchange_client.request import DescribeRateModelMastersRequest
from gs2_exchange_client.result import DescribeRateModelMastersResult

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

result = client.describe_rate_model_masters_async(
    DescribeRateModelMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.exchange.request.DescribeRateModelMastersRequest
import io.gs2.exchange.result.DescribeRateModelMastersResult

result = client.describeRateModelMasters(
    DescribeRateModelMastersRequest()
        .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[RateModelMaster] 交換レートマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeRateModels

同期処理

from gs2_exchange_client.request import DescribeRateModelsRequest
from gs2_exchange_client.result import DescribeRateModelsResult

result = client.describe_rate_models(
    DescribeRateModelsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.exchange.request.DescribeRateModelsRequest
import io.gs2.exchange.result.DescribeRateModelsResult

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

非同期処理

from gs2_exchange_client.request import DescribeRateModelsRequest
from gs2_exchange_client.result import DescribeRateModelsResult

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

result = client.describe_rate_models_async(
    DescribeRateModelsRequest()\
    callback
)
import io.gs2.exchange.request.DescribeRateModelsRequest
import io.gs2.exchange.result.DescribeRateModelsResult

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

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

交換レートモデルの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[RateModel] 交換レートモデルのリスト

exchange

同期処理

from gs2_exchange_client.request import ExchangeRequest
from gs2_exchange_client.result import ExchangeResult

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

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

非同期処理

from gs2_exchange_client.request import ExchangeRequest
from gs2_exchange_client.result import ExchangeResult

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

result = client.exchange_async(
    ExchangeRequest()\
    callback
)
import io.gs2.exchange.request.ExchangeRequest
import io.gs2.exchange.result.ExchangeResult

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

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

交換を実行

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
rateName string true 交換レートの種類名
count integer true 交換するロット数
config list[Config] false 設定値
パラメータ データ型 説明
item RateModel 交換レートモデル
stampSheet string 交換処理の実行に使用するスタンプシート

exchangeByUserId

同期処理

from gs2_exchange_client.request import ExchangeByUserIdRequest
from gs2_exchange_client.result import ExchangeByUserIdResult

result = client.exchange_by_user_id(
    ExchangeByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.exchange.request.ExchangeByUserIdRequest
import io.gs2.exchange.result.ExchangeByUserIdResult

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

非同期処理

from gs2_exchange_client.request import ExchangeByUserIdRequest
from gs2_exchange_client.result import ExchangeByUserIdResult

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

result = client.exchange_by_user_id_async(
    ExchangeByUserIdRequest()\
    callback
)
import io.gs2.exchange.request.ExchangeByUserIdRequest
import io.gs2.exchange.result.ExchangeByUserIdResult

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

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

ユーザIDを指定して交換を実行

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
rateName string true 交換レートの種類名
userId string false ユーザーID
count integer true 交換するロット数
config list[Config] false 設定値
パラメータ データ型 説明
item RateModel 交換レートモデル
stampSheet string 交換処理の実行に使用するスタンプシート

exportMaster

同期処理

from gs2_exchange_client.request import ExportMasterRequest
from gs2_exchange_client.result import ExportMasterResult

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

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

非同期処理

from gs2_exchange_client.request import ExportMasterRequest
from gs2_exchange_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.exchange.request.ExportMasterRequest
import io.gs2.exchange.result.ExportMasterResult

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

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

現在有効な交換レート設定のマスターデータをエクスポートします

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentRateMaster 現在有効な交換レート設定

getCurrentRateMaster

同期処理

from gs2_exchange_client.request import GetCurrentRateMasterRequest
from gs2_exchange_client.result import GetCurrentRateMasterResult

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

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

非同期処理

from gs2_exchange_client.request import GetCurrentRateMasterRequest
from gs2_exchange_client.result import GetCurrentRateMasterResult

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

result = client.get_current_rate_master_async(
    GetCurrentRateMasterRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.exchange.request.GetCurrentRateMasterRequest
import io.gs2.exchange.result.GetCurrentRateMasterResult

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

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

現在有効な交換レート設定を取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentRateMaster 現在有効な交換レート設定

getNamespace

同期処理

from gs2_exchange_client.request import GetNamespaceRequest
from gs2_exchange_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_exchange_client.request import GetNamespaceRequest
from gs2_exchange_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.exchange.request.GetNamespaceRequest
import io.gs2.exchange.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_exchange_client.request import GetNamespaceStatusRequest
from gs2_exchange_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_exchange_client.request import GetNamespaceStatusRequest
from gs2_exchange_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.exchange.request.GetNamespaceStatusRequest
import io.gs2.exchange.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

getRateModel

同期処理

from gs2_exchange_client.request import GetRateModelRequest
from gs2_exchange_client.result import GetRateModelResult

result = client.get_rate_model(
    GetRateModelRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.exchange.request.GetRateModelRequest
import io.gs2.exchange.result.GetRateModelResult

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

非同期処理

from gs2_exchange_client.request import GetRateModelRequest
from gs2_exchange_client.result import GetRateModelResult

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

result = client.get_rate_model_async(
    GetRateModelRequest()\
    callback
)
import io.gs2.exchange.request.GetRateModelRequest
import io.gs2.exchange.result.GetRateModelResult

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

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

交換レートモデルを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
rateName string true 交換レート名
パラメータ データ型 説明
item RateModel 交換レートモデル

getRateModelMaster

同期処理

from gs2_exchange_client.request import GetRateModelMasterRequest
from gs2_exchange_client.result import GetRateModelMasterResult

result = client.get_rate_model_master(
    GetRateModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_rate_name('rate-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.exchange.request.GetRateModelMasterRequest
import io.gs2.exchange.result.GetRateModelMasterResult

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

非同期処理

from gs2_exchange_client.request import GetRateModelMasterRequest
from gs2_exchange_client.result import GetRateModelMasterResult

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

result = client.get_rate_model_master_async(
    GetRateModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_rate_name('rate-0001'),
    callback
)
import io.gs2.exchange.request.GetRateModelMasterRequest
import io.gs2.exchange.result.GetRateModelMasterResult

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

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

交換レートマスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
rateName string true 交換レート名
パラメータ データ型 説明
item RateModelMaster 交換レートマスター

updateCurrentRateMaster

同期処理

from gs2_exchange_client.request import UpdateCurrentRateMasterRequest
from gs2_exchange_client.result import UpdateCurrentRateMasterResult

result = client.update_current_rate_master(
    UpdateCurrentRateMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-08-19",\n  "rateModels": [\n    {\n      "name": "material_n_to_r",\n      "metadata": "N2R",\n      "consumeActions": [\n        {\n          "action": "Gs2Inventory:ConsumeItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}"\n        }\n      ],\n      "acquireActions": [\n        {\n          "action": "Gs2Inventory:AcquireItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1}"\n        }\n      ]\n    },\n    {\n      "name": "material_r_to_n",\n      "metadata": "N2R",\n      "consumeActions": [\n        {\n          "action": "Gs2Inventory:ConsumeItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 1}"\n        }\n      ],\n      "acquireActions": [\n        {\n          "action": "Gs2Inventory:AcquireItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 10}"\n        }\n      ]\n    }\n  ]\n}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.exchange.request.UpdateCurrentRateMasterRequest
import io.gs2.exchange.result.UpdateCurrentRateMasterResult

result = client.updateCurrentRateMaster(
    UpdateCurrentRateMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-08-19",\n  "rateModels": [\n    {\n      "name": "material_n_to_r",\n      "metadata": "N2R",\n      "consumeActions": [\n        {\n          "action": "Gs2Inventory:ConsumeItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}"\n        }\n      ],\n      "acquireActions": [\n        {\n          "action": "Gs2Inventory:AcquireItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1}"\n        }\n      ]\n    },\n    {\n      "name": "material_r_to_n",\n      "metadata": "N2R",\n      "consumeActions": [\n        {\n          "action": "Gs2Inventory:ConsumeItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 1}"\n        }\n      ],\n      "acquireActions": [\n        {\n          "action": "Gs2Inventory:AcquireItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 10}"\n        }\n      ]\n    }\n  ]\n}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_exchange_client.request import UpdateCurrentRateMasterRequest
from gs2_exchange_client.result import UpdateCurrentRateMasterResult

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

result = client.update_current_rate_master_async(
    UpdateCurrentRateMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-08-19",\n  "rateModels": [\n    {\n      "name": "material_n_to_r",\n      "metadata": "N2R",\n      "consumeActions": [\n        {\n          "action": "Gs2Inventory:ConsumeItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}"\n        }\n      ],\n      "acquireActions": [\n        {\n          "action": "Gs2Inventory:AcquireItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1}"\n        }\n      ]\n    },\n    {\n      "name": "material_r_to_n",\n      "metadata": "N2R",\n      "consumeActions": [\n        {\n          "action": "Gs2Inventory:ConsumeItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 1}"\n        }\n      ],\n      "acquireActions": [\n        {\n          "action": "Gs2Inventory:AcquireItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 10}"\n        }\n      ]\n    }\n  ]\n}'),
    callback
)
import io.gs2.exchange.request.UpdateCurrentRateMasterRequest
import io.gs2.exchange.result.UpdateCurrentRateMasterResult

result = client.updateCurrentRateMaster(
    UpdateCurrentRateMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-08-19",\n  "rateModels": [\n    {\n      "name": "material_n_to_r",\n      "metadata": "N2R",\n      "consumeActions": [\n        {\n          "action": "Gs2Inventory:ConsumeItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 10}"\n        }\n      ],\n      "acquireActions": [\n        {\n          "action": "Gs2Inventory:AcquireItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 1}"\n        }\n      ]\n    },\n    {\n      "name": "material_r_to_n",\n      "metadata": "N2R",\n      "consumeActions": [\n        {\n          "action": "Gs2Inventory:ConsumeItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0002\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"consumeCount\\\": 1}"\n        }\n      ],\n      "acquireActions": [\n        {\n          "action": "Gs2Inventory:AcquireItemSetByUserId",\n          "request": "{\\\"namespaceName\\\": \\\"category-0001\\\", \\\"inventoryName\\\": \\\"item\\\", \\\"itemName\\\": \\\"item-0001\\\", \\\"userId\\\": \\\"#{userId}\\\", \\\"acquireCount\\\": 10}"\n        }\n      ]\n    }\n  ]\n}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Exchange::CurrentRateMaster
Properties:
  NamespaceName: String
  Settings: String

現在有効な交換レート設定を更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
settings string true マスターデータ
パラメータ データ型 説明
item CurrentRateMaster 更新した現在有効な交換レート設定

updateCurrentRateMasterFromGitHub

同期処理

from gs2_exchange_client.request import UpdateCurrentRateMasterFromGitHubRequest
from gs2_exchange_client.result import UpdateCurrentRateMasterFromGitHubResult

result = client.update_current_rate_master_from_git_hub(
    UpdateCurrentRateMasterFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.exchange.request.UpdateCurrentRateMasterFromGitHubRequest
import io.gs2.exchange.result.UpdateCurrentRateMasterFromGitHubResult

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

非同期処理

from gs2_exchange_client.request import UpdateCurrentRateMasterFromGitHubRequest
from gs2_exchange_client.result import UpdateCurrentRateMasterFromGitHubResult

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

result = client.update_current_rate_master_from_git_hub_async(
    UpdateCurrentRateMasterFromGitHubRequest()\
    callback
)
import io.gs2.exchange.request.UpdateCurrentRateMasterFromGitHubRequest
import io.gs2.exchange.result.UpdateCurrentRateMasterFromGitHubResult

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

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

現在有効な交換レート設定を更新します

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

updateNamespace

同期処理

from gs2_exchange_client.request import UpdateNamespaceRequest
from gs2_exchange_client.result import UpdateNamespaceResult

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

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

非同期処理

from gs2_exchange_client.request import UpdateNamespaceRequest
from gs2_exchange_client.result import UpdateNamespaceResult

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

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

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

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

ネームスペースを更新

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

updateRateModelMaster

同期処理

from gs2_exchange_client.request import UpdateRateModelMasterRequest
from gs2_exchange_client.result import UpdateRateModelMasterResult

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

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

非同期処理

from gs2_exchange_client.request import UpdateRateModelMasterRequest
from gs2_exchange_client.result import UpdateRateModelMasterResult

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

result = client.update_rate_model_master_async(
    UpdateRateModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_rate_name('rate-0001')\
        .with_description('description1')\
        .with_metadata('RATE_0001')\
        .with_acquire_actions([
Object("AcquireAction", {"action": 'Gs2Stamina:RecoverStaminaByUserId', "request": '{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}'})
])\
        .with_consume_actions([
Object("ConsumeAction", {"action": 'Gs2Money:WithdrawByUserId', "request": '{"moneyName": "money-0001", "userId": "user-0001", "slot": 0, "count": 200, "paidOnly": false}'})
]),
    callback
)
import io.gs2.exchange.request.UpdateRateModelMasterRequest
import io.gs2.exchange.result.UpdateRateModelMasterResult

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

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

交換レートマスターを更新

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

GS2-Script トリガーイベント

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

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

CurrentRateMaster

{
  "version": "2019-08-19"
  "rateModels": [
    {
      "name": "[string] 交換レートの種類名",
      "metadata": "[string] 交換レートの種類のメタデータ"
    }
  ]
}

現在有効な交換レート設定

エクスポートしたマスターデータを、現在有効な交換レート設定としてインポートして使用します。

GS2-Exchange の制限・制約

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