NAV Navbar
Python Java GS2-Formation
 

GS2-Distributor

プロパティの増加処理を中継し、対象の所持数量の上限に達していた場合に GS2-Inbox に転送する機能を提供します。 この機能を利用することで、所持数量の上限に到達したときの複雑な分岐処理を無くすことができ、意図しないデータ消失のリスクを回避できます。

その他に、GS2内で一貫性のある処理を実現するための仕組みであるスタンプシートの実行処理にも使用します。

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

モデル

Namespace

ネームスペース

複数の配信設定を束ねるデータです。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false ネームスペースの説明
assumeUserId string true 所持品の配布処理の権限判定に使用する ユーザ のGRN
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

DistributorModelMaster

配信設定マスター

リソースの配布時に使用する権限や、配布しようとしたがキャパシティの上限に達していたときに転送するプレゼントボックスの情報を登録します。 このモデルは配信設定のマスターデータ管理用のモデルです。このデータをエクスポートして使用します。

パラメータ データ型 必須 説明
distributorModelId string true 配信設定マスター
name string true 配信設定名
description string false 配信設定マスターの説明
metadata string false 配信設定のメタデータ
inboxNamespaceId string false 所持品がキャパシティをオーバーしたときに転送するプレゼントボックスのネームスペース のGRN
whiteListTargetIds list[string] false ディストリビューターを通して処理出来る対象のリソースGRNのホワイトリスト
createdAt long true 作成日時
updatedAt long true 最終更新日時

DistributorModel

配信設定

リソースの配布時に使用する権限や、配布しようとしたがキャパシティの上限に達していたときに転送するプレゼントボックスの情報を登録します。

パラメータ データ型 必須 説明
distributorModelId string true 配信設定
name string true ディストリビューターの種類名
metadata string false ディストリビューターの種類のメタデータ
inboxNamespaceId string false 所持品がキャパシティをオーバーしたときに転送するプレゼントボックスのネームスペース のGRN
whiteListTargetIds list[string] false ディストリビューターを通して処理出来る対象のリソースGRNのホワイトリスト

CurrentDistributorMaster

現在有効な配信設定

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

パラメータ データ型 必須 説明
namespaceId string true 現在有効な配信設定
settings string true マスターデータ

Distribute

リソース配信

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

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 タグ名

DistributeResource

加算するリソース

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

LogSetting

ロギング通知設定

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

初期化処理

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

import gs2_core_client.model.*
import gs2_distributor_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_distributor_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 = Gs2DistributorRestClient(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.distributor.rest.Gs2DistributorRestClient

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

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

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

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

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

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

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

import gs2_core_client.model.*
import gs2_distributor_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 = Gs2DistributorWebSocketClient(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.distributor.webSocket.Gs2DistributorWebSocketClient

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

createDistributorModelMaster

同期処理

from gs2_distributor_client.request import CreateDistributorModelMasterRequest
from gs2_distributor_client.result import CreateDistributorModelMasterResult

result = client.create_distributor_model_master(
    CreateDistributorModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('distributor-model-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.distributor.request.CreateDistributorModelMasterRequest
import io.gs2.distributor.result.CreateDistributorModelMasterResult

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

非同期処理

from gs2_distributor_client.request import CreateDistributorModelMasterRequest
from gs2_distributor_client.result import CreateDistributorModelMasterResult

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

result = client.create_distributor_model_master_async(
    CreateDistributorModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('distributor-model-0001'),
    callback
)
import io.gs2.distributor.request.CreateDistributorModelMasterRequest
import io.gs2.distributor.result.CreateDistributorModelMasterResult

result = client.createDistributorModelMaster(
    CreateDistributorModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("distributor-model-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Distributor::DistributorModelMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  InboxNamespaceId: Optional[String]
  WhiteListTargetIds:
    - String
    - String

配信設定マスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true 配信設定名
description string false 配信設定マスターの説明
metadata string false 配信設定のメタデータ
inboxNamespaceId string false 所持品がキャパシティをオーバーしたときに転送するプレゼントボックスのネームスペース のGRN
whiteListTargetIds list[string] false ディストリビューターを通して処理出来る対象のリソースGRNのホワイトリスト
パラメータ データ型 説明
item DistributorModelMaster 作成した配信設定マスター

createNamespace

同期処理

from gs2_distributor_client.request import CreateNamespaceRequest
from gs2_distributor_client.result import CreateNamespaceResult

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

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

非同期処理

from gs2_distributor_client.request import CreateNamespaceRequest
from gs2_distributor_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_assume_user_id('grn:gs2::{ownerId}:identifier:user:user-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.distributor.request.CreateNamespaceRequest
import io.gs2.distributor.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withAssumeUserId("grn:gs2::{ownerId}:identifier:user:user-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::Distributor::Namespace
Properties:
  Name: String
  Description: Optional[String]
  AssumeUserId: String
  LogSetting:
    LoggingNamespaceId: Optional[String]

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

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false ネームスペースの説明
assumeUserId string true 所持品の配布処理の権限判定に使用する ユーザ のGRN
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

deleteDistributorModelMaster

同期処理

from gs2_distributor_client.request import DeleteDistributorModelMasterRequest
from gs2_distributor_client.result import DeleteDistributorModelMasterResult

result = client.delete_distributor_model_master(
    DeleteDistributorModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_distributor_name('distributor-model-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.distributor.request.DeleteDistributorModelMasterRequest
import io.gs2.distributor.result.DeleteDistributorModelMasterResult

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

非同期処理

from gs2_distributor_client.request import DeleteDistributorModelMasterRequest
from gs2_distributor_client.result import DeleteDistributorModelMasterResult

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

result = client.delete_distributor_model_master_async(
    DeleteDistributorModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_distributor_name('distributor-model-0001'),
    callback
)
import io.gs2.distributor.request.DeleteDistributorModelMasterRequest
import io.gs2.distributor.result.DeleteDistributorModelMasterResult

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

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

配信設定マスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
distributorName string true 配信設定名
パラメータ データ型 説明
item DistributorModelMaster 削除した配信設定マスター

deleteNamespace

同期処理

from gs2_distributor_client.request import DeleteNamespaceRequest
from gs2_distributor_client.result import DeleteNamespaceResult

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

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

非同期処理

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

describeDistributorModelMasters

同期処理

from gs2_distributor_client.request import DescribeDistributorModelMastersRequest
from gs2_distributor_client.result import DescribeDistributorModelMastersResult

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

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

非同期処理

from gs2_distributor_client.request import DescribeDistributorModelMastersRequest
from gs2_distributor_client.result import DescribeDistributorModelMastersResult

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

result = client.describe_distributor_model_masters_async(
    DescribeDistributorModelMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.distributor.request.DescribeDistributorModelMastersRequest
import io.gs2.distributor.result.DescribeDistributorModelMastersResult

result = client.describeDistributorModelMasters(
    DescribeDistributorModelMastersRequest()
        .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[DistributorModelMaster] 配信設定マスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeDistributorModels

同期処理

from gs2_distributor_client.request import DescribeDistributorModelsRequest
from gs2_distributor_client.result import DescribeDistributorModelsResult

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

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

非同期処理

from gs2_distributor_client.request import DescribeDistributorModelsRequest
from gs2_distributor_client.result import DescribeDistributorModelsResult

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

result = client.describe_distributor_models_async(
    DescribeDistributorModelsRequest()\
    callback
)
import io.gs2.distributor.request.DescribeDistributorModelsRequest
import io.gs2.distributor.result.DescribeDistributorModelsResult

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

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

配信設定の一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[DistributorModel] 配信設定のリスト

describeNamespaces

同期処理

from gs2_distributor_client.request import DescribeNamespacesRequest
from gs2_distributor_client.result import DescribeNamespacesResult

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

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

非同期処理

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

distribute

同期処理

from gs2_distributor_client.request import DistributeRequest
from gs2_distributor_client.result import DistributeResult

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

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

非同期処理

from gs2_distributor_client.request import DistributeRequest
from gs2_distributor_client.result import DistributeResult

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

result = client.distribute_async(
    DistributeRequest()\
    callback
)
import io.gs2.distributor.request.DistributeRequest
import io.gs2.distributor.result.DistributeResult

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

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

所持品を配布する

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
distributorName string true ディストリビューターの種類名
distributeResource DistributeResource true 加算するリソース
パラメータ データ型 説明
distributeResource DistributeResource 処理した DistributeResource
inboxNamespaceId string 所持品がキャパシティをオーバーしたときに転送するプレゼントボックスのネームスペース のGRN
result string レスポンス内容

exportMaster

同期処理

from gs2_distributor_client.request import ExportMasterRequest
from gs2_distributor_client.result import ExportMasterResult

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

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

非同期処理

from gs2_distributor_client.request import ExportMasterRequest
from gs2_distributor_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.distributor.request.ExportMasterRequest
import io.gs2.distributor.result.ExportMasterResult

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

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

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

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentDistributorMaster 現在有効な配信設定

getCurrentDistributorMaster

同期処理

from gs2_distributor_client.request import GetCurrentDistributorMasterRequest
from gs2_distributor_client.result import GetCurrentDistributorMasterResult

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

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

非同期処理

from gs2_distributor_client.request import GetCurrentDistributorMasterRequest
from gs2_distributor_client.result import GetCurrentDistributorMasterResult

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

result = client.get_current_distributor_master_async(
    GetCurrentDistributorMasterRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.distributor.request.GetCurrentDistributorMasterRequest
import io.gs2.distributor.result.GetCurrentDistributorMasterResult

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

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

現在有効な配信設定を取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentDistributorMaster 現在有効な配信設定

getDistributorModel

同期処理

from gs2_distributor_client.request import GetDistributorModelRequest
from gs2_distributor_client.result import GetDistributorModelResult

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

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

非同期処理

from gs2_distributor_client.request import GetDistributorModelRequest
from gs2_distributor_client.result import GetDistributorModelResult

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

result = client.get_distributor_model_async(
    GetDistributorModelRequest()\
    callback
)
import io.gs2.distributor.request.GetDistributorModelRequest
import io.gs2.distributor.result.GetDistributorModelResult

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

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

配信設定を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
distributorName string true 配信設定名
パラメータ データ型 説明
item DistributorModel 配信設定

getDistributorModelMaster

同期処理

from gs2_distributor_client.request import GetDistributorModelMasterRequest
from gs2_distributor_client.result import GetDistributorModelMasterResult

result = client.get_distributor_model_master(
    GetDistributorModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_distributor_name('distributor-model-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.distributor.request.GetDistributorModelMasterRequest
import io.gs2.distributor.result.GetDistributorModelMasterResult

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

非同期処理

from gs2_distributor_client.request import GetDistributorModelMasterRequest
from gs2_distributor_client.result import GetDistributorModelMasterResult

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

result = client.get_distributor_model_master_async(
    GetDistributorModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_distributor_name('distributor-model-0001'),
    callback
)
import io.gs2.distributor.request.GetDistributorModelMasterRequest
import io.gs2.distributor.result.GetDistributorModelMasterResult

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

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

配信設定マスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
distributorName string true 配信設定名
パラメータ データ型 説明
item DistributorModelMaster 配信設定マスター

getNamespace

同期処理

from gs2_distributor_client.request import GetNamespaceRequest
from gs2_distributor_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_distributor_client.request import GetNamespaceRequest
from gs2_distributor_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.distributor.request.GetNamespaceRequest
import io.gs2.distributor.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_distributor_client.request import GetNamespaceStatusRequest
from gs2_distributor_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_distributor_client.request import GetNamespaceStatusRequest
from gs2_distributor_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.distributor.request.GetNamespaceStatusRequest
import io.gs2.distributor.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

runStampSheet

同期処理

from gs2_distributor_client.request import RunStampSheetRequest
from gs2_distributor_client.result import RunStampSheetResult

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

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

非同期処理

from gs2_distributor_client.request import RunStampSheetRequest
from gs2_distributor_client.result import RunStampSheetResult

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

result = client.run_stamp_sheet_async(
    RunStampSheetRequest()\
    callback
)
import io.gs2.distributor.request.RunStampSheetRequest
import io.gs2.distributor.result.RunStampSheetResult

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

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

スタンプシートの完了を報告する

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
stampSheet string true 実行するスタンプタスク
keyId string true スタンプシートの暗号化に使用した暗号鍵GRN
パラメータ データ型 説明
result string レスポンス内容

runStampTask

同期処理

from gs2_distributor_client.request import RunStampTaskRequest
from gs2_distributor_client.result import RunStampTaskResult

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

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

非同期処理

from gs2_distributor_client.request import RunStampTaskRequest
from gs2_distributor_client.result import RunStampTaskResult

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

result = client.run_stamp_task_async(
    RunStampTaskRequest()\
    callback
)
import io.gs2.distributor.request.RunStampTaskRequest
import io.gs2.distributor.result.RunStampTaskResult

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

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

スタンプシートのタスクを実行する

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
stampTask string true 実行するスタンプタスク
keyId string true スタンプシートの暗号化に使用した暗号鍵GRN
パラメータ データ型 説明
contextStack string タスクの実行結果を反映したコンテキストスタック
result string レスポンス内容

updateCurrentDistributorMaster

同期処理

from gs2_distributor_client.request import UpdateCurrentDistributorMasterRequest
from gs2_distributor_client.result import UpdateCurrentDistributorMasterResult

result = client.update_current_distributor_master(
    UpdateCurrentDistributorMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-03-01",\n  "distributorModels": [\n    {\n      "name": "basic",\n      "metadata": "BASIC",\n      "inboxNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:inbox:inbox-0001"\n    },\n    {\n      "name": "special",\n      "metadata": "SPECIAL",\n      "inboxNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:inbox:inbox-0001",\n      "whiteListTargetIds": [\n        "test"\n      ]\n    }\n  ]\n}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.distributor.request.UpdateCurrentDistributorMasterRequest
import io.gs2.distributor.result.UpdateCurrentDistributorMasterResult

result = client.updateCurrentDistributorMaster(
    UpdateCurrentDistributorMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-03-01",\n  "distributorModels": [\n    {\n      "name": "basic",\n      "metadata": "BASIC",\n      "inboxNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:inbox:inbox-0001"\n    },\n    {\n      "name": "special",\n      "metadata": "SPECIAL",\n      "inboxNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:inbox:inbox-0001",\n      "whiteListTargetIds": [\n        "test"\n      ]\n    }\n  ]\n}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_distributor_client.request import UpdateCurrentDistributorMasterRequest
from gs2_distributor_client.result import UpdateCurrentDistributorMasterResult

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

result = client.update_current_distributor_master_async(
    UpdateCurrentDistributorMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-03-01",\n  "distributorModels": [\n    {\n      "name": "basic",\n      "metadata": "BASIC",\n      "inboxNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:inbox:inbox-0001"\n    },\n    {\n      "name": "special",\n      "metadata": "SPECIAL",\n      "inboxNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:inbox:inbox-0001",\n      "whiteListTargetIds": [\n        "test"\n      ]\n    }\n  ]\n}'),
    callback
)
import io.gs2.distributor.request.UpdateCurrentDistributorMasterRequest
import io.gs2.distributor.result.UpdateCurrentDistributorMasterResult

result = client.updateCurrentDistributorMaster(
    UpdateCurrentDistributorMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-03-01",\n  "distributorModels": [\n    {\n      "name": "basic",\n      "metadata": "BASIC",\n      "inboxNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:inbox:inbox-0001"\n    },\n    {\n      "name": "special",\n      "metadata": "SPECIAL",\n      "inboxNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:inbox:inbox-0001",\n      "whiteListTargetIds": [\n        "test"\n      ]\n    }\n  ]\n}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Distributor::CurrentDistributorMaster
Properties:
  NamespaceName: String
  Settings: String

現在有効な配信設定を更新します

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

updateCurrentDistributorMasterFromGitHub

同期処理

from gs2_distributor_client.request import UpdateCurrentDistributorMasterFromGitHubRequest
from gs2_distributor_client.result import UpdateCurrentDistributorMasterFromGitHubResult

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

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

非同期処理

from gs2_distributor_client.request import UpdateCurrentDistributorMasterFromGitHubRequest
from gs2_distributor_client.result import UpdateCurrentDistributorMasterFromGitHubResult

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

result = client.update_current_distributor_master_from_git_hub_async(
    UpdateCurrentDistributorMasterFromGitHubRequest()\
    callback
)
import io.gs2.distributor.request.UpdateCurrentDistributorMasterFromGitHubRequest
import io.gs2.distributor.result.UpdateCurrentDistributorMasterFromGitHubResult

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

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

現在有効な配信設定を更新します

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

updateDistributorModelMaster

同期処理

from gs2_distributor_client.request import UpdateDistributorModelMasterRequest
from gs2_distributor_client.result import UpdateDistributorModelMasterResult

result = client.update_distributor_model_master(
    UpdateDistributorModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_distributor_name('distributor-model-0001')\
        .with_description('description1')\
        .with_metadata('{"hoge": "fuga"}')\
        .with_inbox_namespace_id('inbox-0001')\
        .with_white_list_target_ids([
'grn:AAA',  
'grn:BBB'
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.distributor.request.UpdateDistributorModelMasterRequest
import io.gs2.distributor.result.UpdateDistributorModelMasterResult

result = client.updateDistributorModelMaster(
    UpdateDistributorModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withDistributorName("distributor-model-0001")
        .withDescription("description1")
        .withMetadata("{"hoge": "fuga"}")
        .withInboxNamespaceId("inbox-0001")
        .withWhiteListTargetIds(new [] {
"grn:AAA",  
"grn:BBB"
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_distributor_client.request import UpdateDistributorModelMasterRequest
from gs2_distributor_client.result import UpdateDistributorModelMasterResult

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

result = client.update_distributor_model_master_async(
    UpdateDistributorModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_distributor_name('distributor-model-0001')\
        .with_description('description1')\
        .with_metadata('{"hoge": "fuga"}')\
        .with_inbox_namespace_id('inbox-0001')\
        .with_white_list_target_ids([
'grn:AAA',  
'grn:BBB'
]),
    callback
)
import io.gs2.distributor.request.UpdateDistributorModelMasterRequest
import io.gs2.distributor.result.UpdateDistributorModelMasterResult

result = client.updateDistributorModelMaster(
    UpdateDistributorModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withDistributorName("distributor-model-0001")
        .withDescription("description1")
        .withMetadata("{"hoge": "fuga"}")
        .withInboxNamespaceId("inbox-0001")
        .withWhiteListTargetIds(new [] {
"grn:AAA",  
"grn:BBB"
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

配信設定マスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
distributorName string true 配信設定名
description string false 配信設定マスターの説明
metadata string false 配信設定のメタデータ
inboxNamespaceId string false 所持品がキャパシティをオーバーしたときに転送するプレゼントボックスのネームスペース のGRN
whiteListTargetIds list[string] false ディストリビューターを通して処理出来る対象のリソースGRNのホワイトリスト
パラメータ データ型 説明
item DistributorModelMaster 更新した配信設定マスター

updateNamespace

同期処理

from gs2_distributor_client.request import UpdateNamespaceRequest
from gs2_distributor_client.result import UpdateNamespaceResult

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

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

非同期処理

from gs2_distributor_client.request import UpdateNamespaceRequest
from gs2_distributor_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_assume_user_id('grn:gs2::{ownerId}:identifier:user:user-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.distributor.request.UpdateNamespaceRequest
import io.gs2.distributor.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withAssumeUserId("grn:gs2::{ownerId}:identifier:user:user-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 ネームスペースの説明
assumeUserId string true 所持品の配布処理の権限判定に使用する ユーザ のGRN
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

GS2-Script トリガーイベント

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

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

CurrentDistributorMaster

{
  "version": "2019-03-01"
  "distributorModels": [
    {
      "name": "[string] ディストリビューターの種類名",
      "metadata": "[string] ディストリビューターの種類のメタデータ",
      "inboxNamespaceId": "[string] 所持品がキャパシティをオーバーしたときに転送するプレゼントボックスのネームスペース のGRN",
      "whiteListTargetIds": 
      ["[string] ディストリビューターを通して処理出来る対象のリソースGRN"
      ]
    }
  ]
}

現在有効な配信設定

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

GS2-Distributor の制限・制約

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