NAV Navbar
Python Java GS2-Formation
 

GS2-Account

ユーザを識別するためのアカウント管理機能を提供するサービスです。

デバイスの機種変更時にデータを引き継げるようにするために メールアドレス+パスワード や ソーシャルアカウントを利用したデータの引き継ぎ機能に対応しています。

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

モデル

Namespace

ネームスペース

ネームスペースを分ける明確な指針はありません。 ゲーム運営の都合上、ゲームプレイヤーの住んでいる地域ごとに区別して管理したい場合などにネームスペースを分けて管理してください。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false 説明文
changePasswordIfTakeOver boolean false アカウント引き継ぎ時にパスワードを変更するか
createAccountScript ScriptSetting false アカウント新規作成したときに実行するスクリプト
authenticationScript ScriptSetting false 認証したときに実行するスクリプト
createTakeOverScript ScriptSetting false 引き継ぎ情報登録したときに実行するスクリプト
doTakeOverScript ScriptSetting false 引き継ぎ実行したときに実行するスクリプト
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

Account

ゲームプレイヤーアカウント

Account はゲームプレイヤーを特定するためのユーザIDとパスワードを記録します。

パラメータ データ型 必須 説明
accountId string true ゲームプレイヤーアカウント
userId string true アカウントID
password string true パスワード
timeOffset integer true 現在時刻に対する補正値(現在時刻を起点とした秒数)
createdAt long true 作成日時

TakeOver

引き継ぎ設定

TakeOver はアカウントの引き継ぎ設定を保存します。 引き継ぎ設定とは、メールアドレスやソーシャルメディアのアカウントIDなどゲームプレイヤーを識別するためのIDとパスワードを組み合わせたものです。 異なるデバイスにアカウントを引き継ぐときに入力してもらいます。

引き継ぎに成功した際にアカウントのパスワードを変更する機能があります。 これによって、デバイスの引き継ぎを行ったあと、以前使用していたデバイスからの認証がエラーになるようになります。

パラメータ データ型 必須 説明
takeOverId string true 引き継ぎ設定
userId string true ユーザーID
type integer true スロット番号
userIdentifier string true 引き継ぎ用ユーザーID
password string true パスワード
createdAt long true 作成日時

ResponseCache

レスポンスキャッシュ

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

ScriptSetting

スクリプト設定

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

LogSetting

ロギング通知設定

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

初期化処理

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

import gs2_core_client.model.*
import gs2_account_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_account_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 = Gs2AccountRestClient(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.account.rest.Gs2AccountRestClient

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

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

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

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

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

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

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

import gs2_core_client.model.*
import gs2_account_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 = Gs2AccountWebSocketClient(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.account.webSocket.Gs2AccountWebSocketClient

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

authentication

同期処理

from gs2_account_client.request import AuthenticationRequest
from gs2_account_client.result import AuthenticationResult

result = client.authentication(
    AuthenticationRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_key_id('grn:gs2:ap-northeast-1:owner_id:key:namespace-0001:key:key-0001')\
        .with_password('password-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.AuthenticationRequest
import io.gs2.account.result.AuthenticationResult

result = client.authentication(
    AuthenticationRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withKeyId("grn:gs2:ap-northeast-1:owner_id:key:namespace-0001:key:key-0001")
        .withPassword("password-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_account_client.request import AuthenticationRequest
from gs2_account_client.result import AuthenticationResult

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

result = client.authentication_async(
    AuthenticationRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id('user-0001')\
        .with_key_id('grn:gs2:ap-northeast-1:owner_id:key:namespace-0001:key:key-0001')\
        .with_password('password-0001'),
    callback
)
import io.gs2.account.request.AuthenticationRequest
import io.gs2.account.result.AuthenticationResult

result = client.authentication(
    AuthenticationRequest()
        .withNamespaceName("namespace-0001")
        .withUserId("user-0001")
        .withKeyId("grn:gs2:ap-northeast-1:owner_id:key:namespace-0001:key:key-0001")
        .withPassword("password-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ゲームプレイヤーアカウントを認証

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true アカウントID
keyId string true 認証トークンの暗号化に使用する暗号鍵 のGRN
password string true パスワード
パラメータ データ型 説明
item Account ゲームプレイヤーアカウント
body string 署名対象のアカウント情報
signature string 署名

createAccount

同期処理

from gs2_account_client.request import CreateAccountRequest
from gs2_account_client.result import CreateAccountResult

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

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

非同期処理

from gs2_account_client.request import CreateAccountRequest
from gs2_account_client.result import CreateAccountResult

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

result = client.create_account_async(
    CreateAccountRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.account.request.CreateAccountRequest
import io.gs2.account.result.CreateAccountResult

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

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

ゲームプレイヤーアカウントを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Account 作成したゲームプレイヤーアカウント

createNamespace

同期処理

from gs2_account_client.request import CreateNamespaceRequest
from gs2_account_client.result import CreateNamespaceResult

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

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

非同期処理

from gs2_account_client.request import CreateNamespaceRequest
from gs2_account_client.result import CreateNamespaceResult

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

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

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

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

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false 説明文
changePasswordIfTakeOver boolean false アカウント引き継ぎ時にパスワードを変更するか
createAccountScript ScriptSetting false アカウント新規作成したときに実行するスクリプト
authenticationScript ScriptSetting false 認証したときに実行するスクリプト
createTakeOverScript ScriptSetting false 引き継ぎ情報登録したときに実行するスクリプト
doTakeOverScript ScriptSetting false 引き継ぎ実行したときに実行するスクリプト
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

createTakeOver

同期処理

from gs2_account_client.request import CreateTakeOverRequest
from gs2_account_client.result import CreateTakeOverResult

result = client.create_take_over(
    CreateTakeOverRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(0)\
        .with_user_identifier('user-0002@gs2.io')\
        .with_password('password-0003')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.CreateTakeOverRequest
import io.gs2.account.result.CreateTakeOverResult

result = client.createTakeOver(
    CreateTakeOverRequest()
        .withNamespaceName("namespace-0001")
        .withType(0)
        .withUserIdentifier("user-0002@gs2.io")
        .withPassword("password-0003")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_account_client.request import CreateTakeOverRequest
from gs2_account_client.result import CreateTakeOverResult

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

result = client.create_take_over_async(
    CreateTakeOverRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(0)\
        .with_user_identifier('user-0002@gs2.io')\
        .with_password('password-0003'),
    callback
)
import io.gs2.account.request.CreateTakeOverRequest
import io.gs2.account.result.CreateTakeOverResult

result = client.createTakeOver(
    CreateTakeOverRequest()
        .withNamespaceName("namespace-0001")
        .withType(0)
        .withUserIdentifier("user-0002@gs2.io")
        .withPassword("password-0003"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

引き継ぎ設定を新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
type integer true スロット番号
userIdentifier string true 引き継ぎ用ユーザーID
password string true パスワード
パラメータ データ型 説明
item TakeOver 作成した引き継ぎ設定

createTakeOverByUserId

同期処理

from gs2_account_client.request import CreateTakeOverByUserIdRequest
from gs2_account_client.result import CreateTakeOverByUserIdResult

result = client.create_take_over_by_user_id(
    CreateTakeOverByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId'])\
        .with_type(0)\
        .with_user_identifier('user-0001@gs2.io')\
        .with_password('password-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.CreateTakeOverByUserIdRequest
import io.gs2.account.result.CreateTakeOverByUserIdResult

result = client.createTakeOverByUserId(
    CreateTakeOverByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId(account1.get'UserId())
        .withType(0)
        .withUserIdentifier("user-0001@gs2.io")
        .withPassword("password-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_account_client.request import CreateTakeOverByUserIdRequest
from gs2_account_client.result import CreateTakeOverByUserIdResult

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

result = client.create_take_over_by_user_id_async(
    CreateTakeOverByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId'])\
        .with_type(0)\
        .with_user_identifier('user-0001@gs2.io')\
        .with_password('password-0001'),
    callback
)
import io.gs2.account.request.CreateTakeOverByUserIdRequest
import io.gs2.account.result.CreateTakeOverByUserIdResult

result = client.createTakeOverByUserId(
    CreateTakeOverByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId(account1.get'UserId())
        .withType(0)
        .withUserIdentifier("user-0001@gs2.io")
        .withPassword("password-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザーIDを指定して引き継ぎ設定を新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
type integer true スロット番号
userIdentifier string true 引き継ぎ用ユーザーID
password string true パスワード
パラメータ データ型 説明
item TakeOver 作成した引き継ぎ設定

deleteAccount

同期処理

from gs2_account_client.request import DeleteAccountRequest
from gs2_account_client.result import DeleteAccountResult

result = client.delete_account(
    DeleteAccountRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.DeleteAccountRequest
import io.gs2.account.result.DeleteAccountResult

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

非同期処理

from gs2_account_client.request import DeleteAccountRequest
from gs2_account_client.result import DeleteAccountResult

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

result = client.delete_account_async(
    DeleteAccountRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId']),
    callback
)
import io.gs2.account.request.DeleteAccountRequest
import io.gs2.account.result.DeleteAccountResult

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

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

ゲームプレイヤーアカウントを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true アカウントID
パラメータ データ型 説明

deleteNamespace

同期処理

from gs2_account_client.request import DeleteNamespaceRequest
from gs2_account_client.result import DeleteNamespaceResult

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

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

非同期処理

from gs2_account_client.request import DeleteNamespaceRequest
from gs2_account_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.account.request.DeleteNamespaceRequest
import io.gs2.account.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 ネームスペース名
パラメータ データ型 説明

deleteTakeOver

同期処理

from gs2_account_client.request import DeleteTakeOverRequest
from gs2_account_client.result import DeleteTakeOverResult

result = client.delete_take_over(
    DeleteTakeOverRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(1)\
        .with_user_identifier('user-0001@gs2.io')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.DeleteTakeOverRequest
import io.gs2.account.result.DeleteTakeOverResult

result = client.deleteTakeOver(
    DeleteTakeOverRequest()
        .withNamespaceName("namespace-0001")
        .withType(1)
        .withUserIdentifier("user-0001@gs2.io")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_account_client.request import DeleteTakeOverRequest
from gs2_account_client.result import DeleteTakeOverResult

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

result = client.delete_take_over_async(
    DeleteTakeOverRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(1)\
        .with_user_identifier('user-0001@gs2.io'),
    callback
)
import io.gs2.account.request.DeleteTakeOverRequest
import io.gs2.account.result.DeleteTakeOverResult

result = client.deleteTakeOver(
    DeleteTakeOverRequest()
        .withNamespaceName("namespace-0001")
        .withType(1)
        .withUserIdentifier("user-0001@gs2.io"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

引き継ぎ設定を削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
type integer true スロット番号
userIdentifier string false 引き継ぎ用ユーザーID
パラメータ データ型 説明

deleteTakeOverByUserIdentifier

同期処理

from gs2_account_client.request import DeleteTakeOverByUserIdentifierRequest
from gs2_account_client.result import DeleteTakeOverByUserIdentifierResult

result = client.delete_take_over_by_user_identifier(
    DeleteTakeOverByUserIdentifierRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(0)\
        .with_user_identifier('user-0001@gs2.io')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.DeleteTakeOverByUserIdentifierRequest
import io.gs2.account.result.DeleteTakeOverByUserIdentifierResult

result = client.deleteTakeOverByUserIdentifier(
    DeleteTakeOverByUserIdentifierRequest()
        .withNamespaceName("namespace-0001")
        .withType(0)
        .withUserIdentifier("user-0001@gs2.io")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_account_client.request import DeleteTakeOverByUserIdentifierRequest
from gs2_account_client.result import DeleteTakeOverByUserIdentifierResult

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

result = client.delete_take_over_by_user_identifier_async(
    DeleteTakeOverByUserIdentifierRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(0)\
        .with_user_identifier('user-0001@gs2.io'),
    callback
)
import io.gs2.account.request.DeleteTakeOverByUserIdentifierRequest
import io.gs2.account.result.DeleteTakeOverByUserIdentifierResult

result = client.deleteTakeOverByUserIdentifier(
    DeleteTakeOverByUserIdentifierRequest()
        .withNamespaceName("namespace-0001")
        .withType(0)
        .withUserIdentifier("user-0001@gs2.io"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

引き継ぎ設定を削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
type integer true スロット番号
userIdentifier string false 引き継ぎ用ユーザーID
パラメータ データ型 説明

describeAccounts

同期処理

from gs2_account_client.request import DescribeAccountsRequest
from gs2_account_client.result import DescribeAccountsResult

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

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

非同期処理

from gs2_account_client.request import DescribeAccountsRequest
from gs2_account_client.result import DescribeAccountsResult

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

result = client.describe_accounts_async(
    DescribeAccountsRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.account.request.DescribeAccountsRequest
import io.gs2.account.result.DescribeAccountsResult

result = client.describeAccounts(
    DescribeAccountsRequest()
        .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[Account] ゲームプレイヤーアカウントのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeNamespaces

同期処理

from gs2_account_client.request import DescribeNamespacesRequest
from gs2_account_client.result import DescribeNamespacesResult

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

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

非同期処理

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

describeTakeOvers

同期処理

from gs2_account_client.request import DescribeTakeOversRequest
from gs2_account_client.result import DescribeTakeOversResult

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

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

非同期処理

from gs2_account_client.request import DescribeTakeOversRequest
from gs2_account_client.result import DescribeTakeOversResult

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

result = client.describe_take_overs_async(
    DescribeTakeOversRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.account.request.DescribeTakeOversRequest
import io.gs2.account.result.DescribeTakeOversResult

result = client.describeTakeOvers(
    DescribeTakeOversRequest()
        .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[TakeOver] 引き継ぎ設定のリスト
nextPageToken string リストの続きを取得するためのページトークン

describeTakeOversByUserId

同期処理

from gs2_account_client.request import DescribeTakeOversByUserIdRequest
from gs2_account_client.result import DescribeTakeOversByUserIdResult

result = client.describe_take_overs_by_user_id(
    DescribeTakeOversByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.DescribeTakeOversByUserIdRequest
import io.gs2.account.result.DescribeTakeOversByUserIdResult

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

非同期処理

from gs2_account_client.request import DescribeTakeOversByUserIdRequest
from gs2_account_client.result import DescribeTakeOversByUserIdResult

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

result = client.describe_take_overs_by_user_id_async(
    DescribeTakeOversByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId']),
    callback
)
import io.gs2.account.request.DescribeTakeOversByUserIdRequest
import io.gs2.account.result.DescribeTakeOversByUserIdResult

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

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

ユーザーIDを指定して引き継ぎ設定の一覧を取得

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

doTakeOver

同期処理

from gs2_account_client.request import DoTakeOverRequest
from gs2_account_client.result import DoTakeOverResult

result = client.do_take_over(
    DoTakeOverRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(0)\
        .with_user_identifier('user-0001@gs2.io')\
        .with_password('password-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.DoTakeOverRequest
import io.gs2.account.result.DoTakeOverResult

result = client.doTakeOver(
    DoTakeOverRequest()
        .withNamespaceName("namespace-0001")
        .withType(0)
        .withUserIdentifier("user-0001@gs2.io")
        .withPassword("password-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_account_client.request import DoTakeOverRequest
from gs2_account_client.result import DoTakeOverResult

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

result = client.do_take_over_async(
    DoTakeOverRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(0)\
        .with_user_identifier('user-0001@gs2.io')\
        .with_password('password-0001'),
    callback
)
import io.gs2.account.request.DoTakeOverRequest
import io.gs2.account.result.DoTakeOverResult

result = client.doTakeOver(
    DoTakeOverRequest()
        .withNamespaceName("namespace-0001")
        .withType(0)
        .withUserIdentifier("user-0001@gs2.io")
        .withPassword("password-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

引き継ぎ設定を更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
type integer true スロット番号
userIdentifier string true 引き継ぎ用ユーザーID
password string true パスワード
パラメータ データ型 説明
item Account ゲームプレイヤーアカウント

getAccount

同期処理

from gs2_account_client.request import GetAccountRequest
from gs2_account_client.result import GetAccountResult

result = client.get_account(
    GetAccountRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.GetAccountRequest
import io.gs2.account.result.GetAccountResult

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

非同期処理

from gs2_account_client.request import GetAccountRequest
from gs2_account_client.result import GetAccountResult

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

result = client.get_account_async(
    GetAccountRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId']),
    callback
)
import io.gs2.account.request.GetAccountRequest
import io.gs2.account.result.GetAccountResult

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

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

ゲームプレイヤーアカウントを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true アカウントID
パラメータ データ型 説明
item Account ゲームプレイヤーアカウント

getNamespace

同期処理

from gs2_account_client.request import GetNamespaceRequest
from gs2_account_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_account_client.request import GetNamespaceRequest
from gs2_account_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.account.request.GetNamespaceRequest
import io.gs2.account.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_account_client.request import GetNamespaceStatusRequest
from gs2_account_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_account_client.request import GetNamespaceStatusRequest
from gs2_account_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()\
    callback
)
import io.gs2.account.request.GetNamespaceStatusRequest
import io.gs2.account.result.GetNamespaceStatusResult

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

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

ネームスペースを取得

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

getTakeOver

同期処理

from gs2_account_client.request import GetTakeOverRequest
from gs2_account_client.result import GetTakeOverResult

result = client.get_take_over(
    GetTakeOverRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(1)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.GetTakeOverRequest
import io.gs2.account.result.GetTakeOverResult

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

非同期処理

from gs2_account_client.request import GetTakeOverRequest
from gs2_account_client.result import GetTakeOverResult

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

result = client.get_take_over_async(
    GetTakeOverRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(1),
    callback
)
import io.gs2.account.request.GetTakeOverRequest
import io.gs2.account.result.GetTakeOverResult

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

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

引き継ぎ設定を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
type integer true スロット番号
パラメータ データ型 説明
item TakeOver 引き継ぎ設定

getTakeOverByUserId

同期処理

from gs2_account_client.request import GetTakeOverByUserIdRequest
from gs2_account_client.result import GetTakeOverByUserIdResult

result = client.get_take_over_by_user_id(
    GetTakeOverByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId'])\
        .with_type(0)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.GetTakeOverByUserIdRequest
import io.gs2.account.result.GetTakeOverByUserIdResult

result = client.getTakeOverByUserId(
    GetTakeOverByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId(account1.get'UserId())
        .withType(0)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_account_client.request import GetTakeOverByUserIdRequest
from gs2_account_client.result import GetTakeOverByUserIdResult

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

result = client.get_take_over_by_user_id_async(
    GetTakeOverByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId'])\
        .with_type(0),
    callback
)
import io.gs2.account.request.GetTakeOverByUserIdRequest
import io.gs2.account.result.GetTakeOverByUserIdResult

result = client.getTakeOverByUserId(
    GetTakeOverByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withUserId(account1.get'UserId())
        .withType(0),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザーIDを指定して引き継ぎ設定を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
type integer true スロット番号
パラメータ データ型 説明
item TakeOver 引き継ぎ設定

updateNamespace

同期処理

from gs2_account_client.request import UpdateNamespaceRequest
from gs2_account_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_change_password_if_take_over(False)\
        .with_create_account_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_authentication_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_create_take_over_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_do_take_over_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1007', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1008'}))\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.UpdateNamespaceRequest
import io.gs2.account.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withChangePasswordIfTakeOver(false)
        .withCreateAccountScript(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"}))
        .withAuthenticationScript(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"}))
        .withCreateTakeOverScript(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"}))
        .withDoTakeOverScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1007", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1008"}))
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_account_client.request import UpdateNamespaceRequest
from gs2_account_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_change_password_if_take_over(False)\
        .with_create_account_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_authentication_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_create_take_over_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_do_take_over_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1007', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1008'}))\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.account.request.UpdateNamespaceRequest
import io.gs2.account.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withChangePasswordIfTakeOver(false)
        .withCreateAccountScript(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"}))
        .withAuthenticationScript(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"}))
        .withCreateTakeOverScript(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"}))
        .withDoTakeOverScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1007", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1008"}))
        .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 説明文
changePasswordIfTakeOver boolean false アカウント引き継ぎ時にパスワードを変更するか
createAccountScript ScriptSetting false アカウント新規作成したときに実行するスクリプト
authenticationScript ScriptSetting false 認証したときに実行するスクリプト
createTakeOverScript ScriptSetting false 引き継ぎ情報登録したときに実行するスクリプト
doTakeOverScript ScriptSetting false 引き継ぎ実行したときに実行するスクリプト
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

updateTakeOver

同期処理

from gs2_account_client.request import UpdateTakeOverRequest
from gs2_account_client.result import UpdateTakeOverResult

result = client.update_take_over(
    UpdateTakeOverRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(0)\
        .with_old_password('password-0001')\
        .with_password('password-1001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.UpdateTakeOverRequest
import io.gs2.account.result.UpdateTakeOverResult

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

非同期処理

from gs2_account_client.request import UpdateTakeOverRequest
from gs2_account_client.result import UpdateTakeOverResult

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

result = client.update_take_over_async(
    UpdateTakeOverRequest()\
        .with_namespace_name('namespace-0001')\
        .with_type(0)\
        .with_old_password('password-0001')\
        .with_password('password-1001'),
    callback
)
import io.gs2.account.request.UpdateTakeOverRequest
import io.gs2.account.result.UpdateTakeOverResult

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

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

引き継ぎ設定を更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
type integer true スロット番号
oldPassword string true 古いパスワード
password string true 新しいパスワード
パラメータ データ型 説明
item TakeOver 引き継ぎ設定

updateTakeOverByUserId

同期処理

from gs2_account_client.request import UpdateTakeOverByUserIdRequest
from gs2_account_client.result import UpdateTakeOverByUserIdResult

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

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

非同期処理

from gs2_account_client.request import UpdateTakeOverByUserIdRequest
from gs2_account_client.result import UpdateTakeOverByUserIdResult

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

result = client.update_take_over_by_user_id_async(
    UpdateTakeOverByUserIdRequest()\
    callback
)
import io.gs2.account.request.UpdateTakeOverByUserIdRequest
import io.gs2.account.result.UpdateTakeOverByUserIdResult

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

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

引き継ぎ設定を更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
type integer true スロット番号
oldPassword string true 古いパスワード
password string true 新しいパスワード
パラメータ データ型 説明
item TakeOver 引き継ぎ設定

updateTimeOffset

同期処理

from gs2_account_client.request import UpdateTimeOffsetRequest
from gs2_account_client.result import UpdateTimeOffsetResult

result = client.update_time_offset(
    UpdateTimeOffsetRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId'])\
        .with_time_offset(30000)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.account.request.UpdateTimeOffsetRequest
import io.gs2.account.result.UpdateTimeOffsetResult

result = client.updateTimeOffset(
    UpdateTimeOffsetRequest()
        .withNamespaceName("namespace-0001")
        .withUserId(account1.get'UserId())
        .withTimeOffset(30000)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_account_client.request import UpdateTimeOffsetRequest
from gs2_account_client.result import UpdateTimeOffsetResult

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

result = client.update_time_offset_async(
    UpdateTimeOffsetRequest()\
        .with_namespace_name('namespace-0001')\
        .with_user_id(account1['userId'])\
        .with_time_offset(30000),
    callback
)
import io.gs2.account.request.UpdateTimeOffsetRequest
import io.gs2.account.result.UpdateTimeOffsetResult

result = client.updateTimeOffset(
    UpdateTimeOffsetRequest()
        .withNamespaceName("namespace-0001")
        .withUserId(account1.get'UserId())
        .withTimeOffset(30000),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ゲームプレイヤーアカウントの現在時刻に対する補正値を更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true アカウントID
timeOffset integer true 現在時刻に対する補正値(現在時刻を起点とした秒数)
パラメータ データ型 説明
item Account 更新したゲームプレイヤーアカウント

GS2-Script トリガーイベント

CreateAccountTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
account = args['account']  -- type: Account

result = {
    permit=  -- type: boolean
}

アカウント新規作成時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
account Account ゲームプレイヤーアカウント
パラメータ データ型 説明
permit boolean アカウントの作成を許可するか

CreateAccountDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
account = args['account']  -- type: Account

result = {
}

アカウント新規作成完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
account Account ゲームプレイヤーアカウント
パラメータ データ型 説明

AuthenticationTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
account = args['account']  -- type: Account

result = {
    permit=,  -- type: boolean
    force=  -- type: boolean
}

認証時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
account Account ゲームプレイヤーアカウント
パラメータ データ型 説明
permit boolean アカウントの認証を許可するか
force boolean パスワード認証に失敗しても認証を通すか

AuthenticationDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
account = args['account']  -- type: Account

result = {
}

認証完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
account Account ゲームプレイヤーアカウント
パラメータ データ型 説明

CreateTakeOverTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
take_over = args['takeOver']  -- type: TakeOver
account = args['account']  -- type: Account

result = {
    permit=  -- type: boolean
}

引き継ぎ情報登録時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
takeOver TakeOver 引き継ぎ設定
account Account ゲームプレイヤーアカウント
パラメータ データ型 説明
permit boolean 引き継ぎ情報登録を許可するか

CreateTakeOverDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
take_over = args['takeOver']  -- type: TakeOver
account = args['account']  -- type: Account

result = {
}

引き継ぎ情報登録完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
takeOver TakeOver 引き継ぎ設定
account Account ゲームプレイヤーアカウント
パラメータ データ型 説明

DoTakeOverTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
account = args['account']  -- type: Account
take_over = args['takeOver']  -- type: TakeOver

result = {
    permit=,  -- type: boolean
    force=  -- type: boolean
}

引き継ぎ実行時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
account Account ゲームプレイヤーアカウント
takeOver TakeOver 引き継ぎ設定
パラメータ データ型 説明
permit boolean 引き継ぎ実行を許可するか
force boolean パスワード認証に失敗しても認証を通すか

DoTakeOverDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
account = args['account']  -- type: Account
take_over = args['takeOver']  -- type: TakeOver

result = {
}

引き継ぎ実行完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
account Account ゲームプレイヤーアカウント
takeOver TakeOver 引き継ぎ設定
パラメータ データ型 説明

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

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

GS2-Account の制限・制約

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