NAV Navbar
Python Java GS2-Formation
 

GS2-Inbox

プレゼントつきのメッセージ機能を提供するサービスです。

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

モデル

Namespace

ネームスペース

メッセージボックスは、作成した ネームスペース ごとに、各ゲームプレイヤーに対して1つ提供されます。 1つのメッセージボックスには複数のメッセージを格納することができます。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true プレゼントボックス名
description string false 説明文
isAutomaticDeletingEnabled boolean false 開封したメッセージを自動的に削除するか
receiveMessageScript ScriptSetting false メッセージ受信したときに実行するスクリプト
readMessageScript ScriptSetting false メッセージ開封したときに実行するスクリプト
deleteMessageScript ScriptSetting false メッセージ削除したときに実行するスクリプト
queueNamespaceId string false 報酬付与処理をジョブとして追加するキューネームスペース のGRN
keyId string false 報酬付与処理のスタンプシートで使用する暗号鍵GRN
receiveNotification NotificationSetting false メッセージを受信したときのプッシュ通知
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

User

ユーザ

パラメータ データ型 必須 説明
userId string true ユーザーID

Message

メッセージ

プレゼントボックスに届いたメッセージデータ。 メッセージの保存期間は最長12ヶ月の制限があります。

パラメータ データ型 必須 説明
messageId string true メッセージ
name string false メッセージID
userId string false ユーザーID
metadata string true メッセージの内容に相当するメタデータ
isRead boolean true 既読状態
readAcquireActions list[AcquireAction] false 開封時に実行する入手アクション
receivedAt long true 作成日時
readAt long 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

ScriptSetting

スクリプト設定

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

NotificationSetting

プッシュ通知設定

パラメータ データ型 必須 説明
gatewayNamespaceId string false プッシュ通知に使用する GS2-Gateway のネームスペース のGRN
enableTransferMobileNotification boolean false モバイルプッシュ通知へ転送するか
sound string false モバイルプッシュ通知で使用するサウンドファイル名

LogSetting

ロギング通知設定

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

AcquireAction

入手アクション

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

初期化処理

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

import gs2_core_client.model.*
import gs2_inbox_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_inbox_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 = Gs2InboxRestClient(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.inbox.rest.Gs2InboxRestClient

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

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

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

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

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

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

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

import gs2_core_client.model.*
import gs2_inbox_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 = Gs2InboxWebSocketClient(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.inbox.webSocket.Gs2InboxWebSocketClient

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

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

GS2-Inbox は 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_inbox_client.request import CreateNamespaceRequest
from gs2_inbox_client.result import CreateNamespaceResult

result = client.create_namespace(
    CreateNamespaceRequest()\
        .with_name('namespace-0001')\
        .with_queue_namespace_id('grn:gs2:{region}:{ownerId}:queue:namespace-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.inbox.request.CreateNamespaceRequest
import io.gs2.inbox.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withQueueNamespaceId("grn:gs2:{region}:{ownerId}:queue:namespace-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_inbox_client.request import CreateNamespaceRequest
from gs2_inbox_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:namespace-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.inbox.request.CreateNamespaceRequest
import io.gs2.inbox.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withQueueNamespaceId("grn:gs2:{region}:{ownerId}:queue:namespace-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::Inbox::Namespace
Properties:
  Name: String
  Description: Optional[String]
  IsAutomaticDeletingEnabled: Optional[Bool]
  ReceiveMessageScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  ReadMessageScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  DeleteMessageScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  QueueNamespaceId: Optional[String]
  KeyId: Optional[String]
  ReceiveNotification:
    GatewayNamespaceId: Optional[String]
    EnableTransferMobileNotification: Optional[Bool]
    Sound: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

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

パラメータ データ型 必須 説明
name string true プレゼントボックス名
description string false 説明文
isAutomaticDeletingEnabled boolean false 開封したメッセージを自動的に削除するか
receiveMessageScript ScriptSetting false メッセージ受信したときに実行するスクリプト
readMessageScript ScriptSetting false メッセージ開封したときに実行するスクリプト
deleteMessageScript ScriptSetting false メッセージ削除したときに実行するスクリプト
queueNamespaceId string false 報酬付与処理をジョブとして追加するキューネームスペース のGRN
keyId string false 報酬付与処理のスタンプシートで使用する暗号鍵GRN
receiveNotification NotificationSetting false メッセージを受信したときのプッシュ通知
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

deleteMessage

同期処理

from gs2_inbox_client.request import DeleteMessageRequest
from gs2_inbox_client.result import DeleteMessageResult

result = client.delete_message(
    DeleteMessageRequest()\
        .with_namespace_name('namespace-0001')\
        .with_message_name(message1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inbox.request.DeleteMessageRequest
import io.gs2.inbox.result.DeleteMessageResult

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

非同期処理

from gs2_inbox_client.request import DeleteMessageRequest
from gs2_inbox_client.result import DeleteMessageResult

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

result = client.delete_message_async(
    DeleteMessageRequest()\
        .with_namespace_name('namespace-0001')\
        .with_message_name(message1['name']),
    callback
)
import io.gs2.inbox.request.DeleteMessageRequest
import io.gs2.inbox.result.DeleteMessageResult

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

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

メッセージを削除

パラメータ データ型 必須 説明
namespaceName string true プレゼントボックス名
messageName string false メッセージID
パラメータ データ型 説明

deleteMessageByUserId

同期処理

from gs2_inbox_client.request import DeleteMessageByUserIdRequest
from gs2_inbox_client.result import DeleteMessageByUserIdResult

result = client.delete_message_by_user_id(
    DeleteMessageByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_message_name(message2['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inbox.request.DeleteMessageByUserIdRequest
import io.gs2.inbox.result.DeleteMessageByUserIdResult

result = client.deleteMessageByUserId(
    DeleteMessageByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withMessageName(message2.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inbox_client.request import DeleteMessageByUserIdRequest
from gs2_inbox_client.result import DeleteMessageByUserIdResult

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

result = client.delete_message_by_user_id_async(
    DeleteMessageByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_message_name(message2['name']),
    callback
)
import io.gs2.inbox.request.DeleteMessageByUserIdRequest
import io.gs2.inbox.result.DeleteMessageByUserIdResult

result = client.deleteMessageByUserId(
    DeleteMessageByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withMessageName(message2.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザーIDを指定してメッセージを削除

パラメータ データ型 必須 説明
namespaceName string true プレゼントボックス名
userId string false ユーザーID
messageName string false メッセージID
パラメータ データ型 説明

deleteNamespace

同期処理

from gs2_inbox_client.request import DeleteNamespaceRequest
from gs2_inbox_client.result import DeleteNamespaceResult

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

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

非同期処理

from gs2_inbox_client.request import DeleteNamespaceRequest
from gs2_inbox_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.inbox.request.DeleteNamespaceRequest
import io.gs2.inbox.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 プレゼントボックス名
パラメータ データ型 説明

describeMessages

同期処理

from gs2_inbox_client.request import DescribeMessagesRequest
from gs2_inbox_client.result import DescribeMessagesResult

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

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

非同期処理

from gs2_inbox_client.request import DescribeMessagesRequest
from gs2_inbox_client.result import DescribeMessagesResult

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

result = client.describe_messages_async(
    DescribeMessagesRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.inbox.request.DescribeMessagesRequest
import io.gs2.inbox.result.DescribeMessagesResult

result = client.describeMessages(
    DescribeMessagesRequest()
        .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[Message] メッセージのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeMessagesByUserId

同期処理

from gs2_inbox_client.request import DescribeMessagesByUserIdRequest
from gs2_inbox_client.result import DescribeMessagesByUserIdResult

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

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

非同期処理

from gs2_inbox_client.request import DescribeMessagesByUserIdRequest
from gs2_inbox_client.result import DescribeMessagesByUserIdResult

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

result = client.describe_messages_by_user_id_async(
    DescribeMessagesByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.inbox.request.DescribeMessagesByUserIdRequest
import io.gs2.inbox.result.DescribeMessagesByUserIdResult

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

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

メッセージの一覧を取得

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

describeNamespaces

同期処理

from gs2_inbox_client.request import DescribeNamespacesRequest
from gs2_inbox_client.result import DescribeNamespacesResult

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

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

非同期処理

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

getMessage

同期処理

from gs2_inbox_client.request import GetMessageRequest
from gs2_inbox_client.result import GetMessageResult

result = client.get_message(
    GetMessageRequest()\
        .with_namespace_name('namespace-0001')\
        .with_message_name(message1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inbox.request.GetMessageRequest
import io.gs2.inbox.result.GetMessageResult

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

非同期処理

from gs2_inbox_client.request import GetMessageRequest
from gs2_inbox_client.result import GetMessageResult

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

result = client.get_message_async(
    GetMessageRequest()\
        .with_namespace_name('namespace-0001')\
        .with_message_name(message1['name']),
    callback
)
import io.gs2.inbox.request.GetMessageRequest
import io.gs2.inbox.result.GetMessageResult

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

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

メッセージを取得

パラメータ データ型 必須 説明
namespaceName string true プレゼントボックス名
messageName string false メッセージID
パラメータ データ型 説明
item Message メッセージ

getMessageByUserId

同期処理

from gs2_inbox_client.request import GetMessageByUserIdRequest
from gs2_inbox_client.result import GetMessageByUserIdResult

result = client.get_message_by_user_id(
    GetMessageByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_message_name(message2['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inbox.request.GetMessageByUserIdRequest
import io.gs2.inbox.result.GetMessageByUserIdResult

result = client.getMessageByUserId(
    GetMessageByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withMessageName(message2.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inbox_client.request import GetMessageByUserIdRequest
from gs2_inbox_client.result import GetMessageByUserIdResult

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

result = client.get_message_by_user_id_async(
    GetMessageByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_message_name(message2['name']),
    callback
)
import io.gs2.inbox.request.GetMessageByUserIdRequest
import io.gs2.inbox.result.GetMessageByUserIdResult

result = client.getMessageByUserId(
    GetMessageByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withMessageName(message2.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザーIDを指定してメッセージを取得

パラメータ データ型 必須 説明
namespaceName string true プレゼントボックス名
userId string false ユーザーID
messageName string false メッセージID
パラメータ データ型 説明
item Message メッセージ

getNamespace

同期処理

from gs2_inbox_client.request import GetNamespaceRequest
from gs2_inbox_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_inbox_client.request import GetNamespaceRequest
from gs2_inbox_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.inbox.request.GetNamespaceRequest
import io.gs2.inbox.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_inbox_client.request import GetNamespaceStatusRequest
from gs2_inbox_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_inbox_client.request import GetNamespaceStatusRequest
from gs2_inbox_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.inbox.request.GetNamespaceStatusRequest
import io.gs2.inbox.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

openByStampTask

同期処理

from gs2_inbox_client.request import OpenByStampTaskRequest
from gs2_inbox_client.result import OpenByStampTaskResult

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

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

非同期処理

from gs2_inbox_client.request import OpenByStampTaskRequest
from gs2_inbox_client.result import OpenByStampTaskResult

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

result = client.open_by_stamp_task_async(
    OpenByStampTaskRequest()\
    callback
)
import io.gs2.inbox.request.OpenByStampTaskRequest
import io.gs2.inbox.result.OpenByStampTaskResult

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

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

メッセージを作成

パラメータ データ型 必須 説明
stampTask string true スタンプタスク
keyId string true スタンプタスクの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Message メッセージ
newContextStack string スタンプタスクの実行結果を記録したコンテキスト

openMessage

同期処理

from gs2_inbox_client.request import OpenMessageRequest
from gs2_inbox_client.result import OpenMessageResult

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

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

非同期処理

from gs2_inbox_client.request import OpenMessageRequest
from gs2_inbox_client.result import OpenMessageResult

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

result = client.open_message_async(
    OpenMessageRequest()\
    callback
)
import io.gs2.inbox.request.OpenMessageRequest
import io.gs2.inbox.result.OpenMessageResult

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

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

メッセージを開封

パラメータ データ型 必須 説明
namespaceName string true プレゼントボックス名
messageName string false メッセージID
パラメータ データ型 説明
item Message メッセージ

openMessageByUserId

同期処理

from gs2_inbox_client.request import OpenMessageByUserIdRequest
from gs2_inbox_client.result import OpenMessageByUserIdResult

result = client.open_message_by_user_id(
    OpenMessageByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_message_name(message1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inbox.request.OpenMessageByUserIdRequest
import io.gs2.inbox.result.OpenMessageByUserIdResult

result = client.openMessageByUserId(
    OpenMessageByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withMessageName(message1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inbox_client.request import OpenMessageByUserIdRequest
from gs2_inbox_client.result import OpenMessageByUserIdResult

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

result = client.open_message_by_user_id_async(
    OpenMessageByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_message_name(message1['name']),
    callback
)
import io.gs2.inbox.request.OpenMessageByUserIdRequest
import io.gs2.inbox.result.OpenMessageByUserIdResult

result = client.openMessageByUserId(
    OpenMessageByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withMessageName(message1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザーIDを指定してメッセージを開封

パラメータ データ型 必須 説明
namespaceName string true プレゼントボックス名
userId string false ユーザーID
messageName string false メッセージID
パラメータ データ型 説明
item Message メッセージ

readMessage

同期処理

from gs2_inbox_client.request import ReadMessageRequest
from gs2_inbox_client.result import ReadMessageResult

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

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

非同期処理

from gs2_inbox_client.request import ReadMessageRequest
from gs2_inbox_client.result import ReadMessageResult

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

result = client.read_message_async(
    ReadMessageRequest()\
    callback
)
import io.gs2.inbox.request.ReadMessageRequest
import io.gs2.inbox.result.ReadMessageResult

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

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

メッセージを開封

パラメータ データ型 必須 説明
namespaceName string true プレゼントボックス名
messageName string false メッセージID
config list[Config] false スタンプシートの変数に適用する設定値
パラメータ データ型 説明
item Message メッセージ
stampSheet string スタンプシート

readMessageByUserId

同期処理

from gs2_inbox_client.request import ReadMessageByUserIdRequest
from gs2_inbox_client.result import ReadMessageByUserIdResult

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

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

非同期処理

from gs2_inbox_client.request import ReadMessageByUserIdRequest
from gs2_inbox_client.result import ReadMessageByUserIdResult

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

result = client.read_message_by_user_id_async(
    ReadMessageByUserIdRequest()\
    callback
)
import io.gs2.inbox.request.ReadMessageByUserIdRequest
import io.gs2.inbox.result.ReadMessageByUserIdResult

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

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

ユーザーIDを指定してメッセージを開封

パラメータ データ型 必須 説明
namespaceName string true プレゼントボックス名
userId string false ユーザーID
messageName string false メッセージID
config list[Config] false スタンプシートの変数に適用する設定値
パラメータ データ型 説明
item Message メッセージ
stampSheet string スタンプシート

sendMessageByUserId

同期処理

from gs2_inbox_client.request import SendMessageByUserIdRequest
from gs2_inbox_client.result import SendMessageByUserIdResult

result = client.send_message_by_user_id(
    SendMessageByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_metadata('{"type": "message", "body": "hello"}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.inbox.request.SendMessageByUserIdRequest
import io.gs2.inbox.result.SendMessageByUserIdResult

result = client.sendMessageByUserId(
    SendMessageByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withMetadata("{"type": "message", "body": "hello"}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_inbox_client.request import SendMessageByUserIdRequest
from gs2_inbox_client.result import SendMessageByUserIdResult

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

result = client.send_message_by_user_id_async(
    SendMessageByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_metadata('{"type": "message", "body": "hello"}'),
    callback
)
import io.gs2.inbox.request.SendMessageByUserIdRequest
import io.gs2.inbox.result.SendMessageByUserIdResult

result = client.sendMessageByUserId(
    SendMessageByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withMetadata("{"type": "message", "body": "hello"}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

メッセージを新規作成

パラメータ データ型 必須 説明
namespaceName string true プレゼントボックス名
userId string false ユーザーID
metadata string true メッセージの内容に相当するメタデータ
readAcquireActions list[AcquireAction] false 開封時に実行する入手アクション
パラメータ データ型 説明
item Message 作成したメッセージ

updateNamespace

同期処理

from gs2_inbox_client.request import UpdateNamespaceRequest
from gs2_inbox_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_is_automatic_deleting_enabled(False)\
        .with_receive_message_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1001', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1002'}))\
        .with_read_message_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1003', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1004'}))\
        .with_delete_message_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1005', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1006'}))\
        .with_queue_namespace_id('grn:gs2:{region}:{ownerId}:queue:namespace-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.inbox.request.UpdateNamespaceRequest
import io.gs2.inbox.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withIsAutomaticDeletingEnabled(false)
        .withReceiveMessageScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1001", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1002"}))
        .withReadMessageScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1003", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1004"}))
        .withDeleteMessageScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1005", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1006"}))
        .withQueueNamespaceId("grn:gs2:{region}:{ownerId}:queue:namespace-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_inbox_client.request import UpdateNamespaceRequest
from gs2_inbox_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_is_automatic_deleting_enabled(False)\
        .with_receive_message_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1001', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1002'}))\
        .with_read_message_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1003', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1004'}))\
        .with_delete_message_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1005', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1006'}))\
        .with_queue_namespace_id('grn:gs2:{region}:{ownerId}:queue:namespace-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.inbox.request.UpdateNamespaceRequest
import io.gs2.inbox.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withIsAutomaticDeletingEnabled(false)
        .withReceiveMessageScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1001", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1002"}))
        .withReadMessageScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1003", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1004"}))
        .withDeleteMessageScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1005", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1006"}))
        .withQueueNamespaceId("grn:gs2:{region}:{ownerId}:queue:namespace-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() で成功結果を取得
    }
)

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

ネームスペースを更新

パラメータ データ型 必須 説明
namespaceName string true プレゼントボックス名
description string false 説明文
isAutomaticDeletingEnabled boolean false 開封したメッセージを自動的に削除するか
receiveMessageScript ScriptSetting false メッセージ受信したときに実行するスクリプト
readMessageScript ScriptSetting false メッセージ開封したときに実行するスクリプト
deleteMessageScript ScriptSetting false メッセージ削除したときに実行するスクリプト
queueNamespaceId string false 報酬付与処理をジョブとして追加するキューネームスペース のGRN
keyId string false 報酬付与処理のスタンプシートで使用する暗号鍵GRN
receiveNotification NotificationSetting false メッセージを受信したときのプッシュ通知
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

GS2-Script トリガーイベント

ReceiveMessageTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
messages = args['messages']  -- type: list[Message]

result = {
    permit=,  -- type: boolean
    overrides=  -- type: Dictionary
}

メッセージ受信時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
messages list[Message] メッセージのリスト
パラメータ データ型 説明
permit boolean メッセージ受信 を許可するか
overrides Dictionary メッセージのメタデータを上書きしたい場合に指定

ReceiveMessageDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
messages = args['messages']  -- type: list[Message]

result = {
}

メッセージ受信完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
messages list[Message] メッセージのリスト
パラメータ データ型 説明

ReadMessageTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
message = args['message']  -- type: Message

result = {
    permit=,  -- type: boolean
    errorMessage=  -- type: string
}

メッセージ開封時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
message Message メッセージ
パラメータ データ型 説明
permit boolean メッセージ開封 を許可するか
errorMessage string メッセージ開封似失敗した時に応答するメッセージ

ReadMessageDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
message = args['message']  -- type: Message

result = {
}

メッセージ開封完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
message Message メッセージ
パラメータ データ型 説明

DeleteMessageTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
message = args['message']  -- type: Message

result = {
    permit=,  -- type: boolean
    denyMessageIds=  -- type: list[string]
}

メッセージ削除時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
message Message メッセージ
パラメータ データ型 説明
permit boolean メッセージ削除 を許可するか
denyMessageIds list[string] メッセージ削除 をメッセージ単位で不許可としたい場合に不許可とするメッセージIDを応答のリスト

DeleteMessageDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
message = args['message']  -- type: Message

result = {
}

メッセージ削除完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
message Message メッセージ
パラメータ データ型 説明

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

マスターデータはありません

GS2-Inbox の制限・制約

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