NAV Navbar
Python Java GS2-Formation
 

GS2-Friend

ゲーム内の友達関係を実現するときに使用します。

リクエストを出して、承認されて初めて関係の構築されるフレンドと、 相手の承認手続きなしに構築できるフォローがあります。

ゲームプレイヤーのメタデータとしてプロフィール情報を持たせることができます。 プロフィール情報は 公開 フォロワーに公開 フレンドに公開 のスコープがあり、スコープに応じて他プレイヤーに公開されます。

フレンド・フォロワー数の上限はそれぞれ1万人ですが、連携するサービスによっては各サービスのポリシーに従って追加の制限が加わる可能性があります。

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

モデル

Namespace

ネームスペース

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false ネームスペースの説明
followScript ScriptSetting false フォローされたときに実行するスクリプト
unfollowScript ScriptSetting false アンフォローされたときに実行するスクリプト
sendRequestScript ScriptSetting false フレンドリクエストを発行したときに実行するスクリプト
cancelRequestScript ScriptSetting false フレンドリクエストをキャンセルしたときに実行するスクリプト
acceptRequestScript ScriptSetting false フレンドリクエストを承諾したときに実行するスクリプト
rejectRequestScript ScriptSetting false フレンドリクエストを拒否したときに実行するスクリプト
deleteFriendScript ScriptSetting false フレンドを削除したときに実行するスクリプト
updateProfileScript ScriptSetting false プロフィールを更新したときに実行するスクリプト
followNotification NotificationSetting false フォローされたときのプッシュ通知
receiveRequestNotification NotificationSetting false フレンドリクエストが届いたときのプッシュ通知
acceptRequestNotification NotificationSetting false フレンドリクエストが承認されたときのプッシュ通知
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

User

ユーザ

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

Profile

プロフィール

プロフィールは 公開 フォロワー向けに公開 フレンド向けに公開 のスコープがあります。

パラメータ データ型 必須 説明
profileId string true プロフィール
userId string true ユーザーID
publicProfile string false 公開されるプロフィール
followerProfile string false フォロワー向けに公開されるプロフィール
friendProfile string false フレンド向けに公開されるプロフィール
createdAt long true 作成日時
updatedAt long true 最終更新日時

Follow

フォロー

各ゲームプレイヤーが誰をフォローしているかを管理します。

パラメータ データ型 必須 説明
followId string true フォロー
userId string true ユーザーID
targetUserIds list[string] false フォローしているユーザーIDリスト
createdAt long true 作成日時
updatedAt long true 最終更新日時

Friend

フレンド

パラメータ データ型 必須 説明
friendId string true フレンド
userId string true ユーザーID
targetUserIds list[string] false フレンドのユーザーIDリスト
createdAt long true 作成日時
updatedAt long true 最終更新日時

SendBox

フレンドリクエストの受信ボックス

パラメータ データ型 必須 説明
sendBoxId string true フレンドリクエストの受信ボックス
userId string true ユーザーID
targetUserIds list[string] false フレンドリクエストを出しているユーザーIDリスト
createdAt long true 作成日時
updatedAt long true 最終更新日時

Inbox

フレンドリクエストの受信ボックス

パラメータ データ型 必須 説明
inboxId string true フレンドリクエストの受信ボックス
userId string true ユーザーID
fromUserIds list[string] false フレンドリクエストを送ってきたユーザーIDリスト
createdAt long true 作成日時
updatedAt long true 最終更新日時

ResponseCache

レスポンスキャッシュ

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

FollowUser

フォローしているユーザー

パラメータ データ型 必須 説明
userId string true ユーザーID
publicProfile string false 公開されるプロフィール
followerProfile string false フォロワー向けに公開されるプロフィール

FriendUser

フレンドのユーザー

パラメータ データ型 必須 説明
userId string true ユーザーID
publicProfile string false 公開されるプロフィール
friendProfile string false フレンド向けに公開されるプロフィール

FriendRequest

フレンドリクエスト

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

PublicProfile

公開プロフィール

パラメータ データ型 必須 説明
userId string true ユーザーID
publicProfile 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

初期化処理

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

import gs2_core_client.model.*
import gs2_friend_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_friend_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 = Gs2FriendRestClient(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.friend.rest.Gs2FriendRestClient

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

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

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

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

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

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

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

import gs2_core_client.model.*
import gs2_friend_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 = Gs2FriendWebSocketClient(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.friend.webSocket.Gs2FriendWebSocketClient

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

acceptRequest

同期処理

from gs2_friend_client.request import AcceptRequestRequest
from gs2_friend_client.result import AcceptRequestResult

result = client.accept_request(
    AcceptRequestRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_from_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.AcceptRequestRequest
import io.gs2.friend.result.AcceptRequestResult

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

非同期処理

from gs2_friend_client.request import AcceptRequestRequest
from gs2_friend_client.result import AcceptRequestResult

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

result = client.accept_request_async(
    AcceptRequestRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_from_user_id('user-0002'),
    callback
)
import io.gs2.friend.request.AcceptRequestRequest
import io.gs2.friend.result.AcceptRequestResult

result = client.acceptRequest(
    AcceptRequestRequest()
        .withNamespaceName("namespaceId-0002")
        .withFromUserId("user-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

フレンドリクエストを承諾

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
fromUserId string true フレンドリクエストを送信したユーザID
パラメータ データ型 説明
item FriendRequest 承諾したフレンドリクエスト

acceptRequestByUserId

同期処理

from gs2_friend_client.request import AcceptRequestByUserIdRequest
from gs2_friend_client.result import AcceptRequestByUserIdResult

result = client.accept_request_by_user_id(
    AcceptRequestByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_from_user_id('user-0003')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.AcceptRequestByUserIdRequest
import io.gs2.friend.result.AcceptRequestByUserIdResult

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

非同期処理

from gs2_friend_client.request import AcceptRequestByUserIdRequest
from gs2_friend_client.result import AcceptRequestByUserIdResult

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

result = client.accept_request_by_user_id_async(
    AcceptRequestByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_from_user_id('user-0003'),
    callback
)
import io.gs2.friend.request.AcceptRequestByUserIdRequest
import io.gs2.friend.result.AcceptRequestByUserIdResult

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

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

ユーザーIDを指定してフレンドリクエストを承諾

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true フレンドリクエストを受け取ったユーザID
fromUserId string true フレンドリクエストを送信したユーザID
パラメータ データ型 説明
item FriendRequest 承諾したフレンドリクエスト

createNamespace

同期処理

from gs2_friend_client.request import CreateNamespaceRequest
from gs2_friend_client.result import CreateNamespaceResult

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

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

非同期処理

from gs2_friend_client.request import CreateNamespaceRequest
from gs2_friend_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('namespaceId-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.friend.request.CreateNamespaceRequest
import io.gs2.friend.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespaceId-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::Friend::Namespace
Properties:
  Name: String
  Description: Optional[String]
  FollowScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  UnfollowScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  SendRequestScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  CancelRequestScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  AcceptRequestScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  RejectRequestScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  DeleteFriendScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  UpdateProfileScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  FollowNotification:
    GatewayNamespaceId: Optional[String]
    EnableTransferMobileNotification: Optional[Bool]
    Sound: Optional[String]
  ReceiveRequestNotification:
    GatewayNamespaceId: Optional[String]
    EnableTransferMobileNotification: Optional[Bool]
    Sound: Optional[String]
  AcceptRequestNotification:
    GatewayNamespaceId: Optional[String]
    EnableTransferMobileNotification: Optional[Bool]
    Sound: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

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

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false ネームスペースの説明
followScript ScriptSetting false フォローされたときに実行するスクリプト
unfollowScript ScriptSetting false アンフォローされたときに実行するスクリプト
sendRequestScript ScriptSetting false フレンドリクエストを発行したときに実行するスクリプト
cancelRequestScript ScriptSetting false フレンドリクエストをキャンセルしたときに実行するスクリプト
acceptRequestScript ScriptSetting false フレンドリクエストを承諾したときに実行するスクリプト
rejectRequestScript ScriptSetting false フレンドリクエストを拒否したときに実行するスクリプト
deleteFriendScript ScriptSetting false フレンドを削除したときに実行するスクリプト
updateProfileScript ScriptSetting false プロフィールを更新したときに実行するスクリプト
followNotification NotificationSetting false フォローされたときのプッシュ通知
receiveRequestNotification NotificationSetting false フレンドリクエストが届いたときのプッシュ通知
acceptRequestNotification NotificationSetting false フレンドリクエストが承認されたときのプッシュ通知
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

deleteFriend

同期処理

from gs2_friend_client.request import DeleteFriendRequest
from gs2_friend_client.result import DeleteFriendResult

result = client.delete_friend(
    DeleteFriendRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DeleteFriendRequest
import io.gs2.friend.result.DeleteFriendResult

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

非同期処理

from gs2_friend_client.request import DeleteFriendRequest
from gs2_friend_client.result import DeleteFriendResult

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

result = client.delete_friend_async(
    DeleteFriendRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002'),
    callback
)
import io.gs2.friend.request.DeleteFriendRequest
import io.gs2.friend.result.DeleteFriendResult

result = client.deleteFriend(
    DeleteFriendRequest()
        .withNamespaceName("namespaceId-0002")
        .withTargetUserId("user-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

フレンドを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
targetUserId string true ユーザーID
パラメータ データ型 説明
item FriendUser フレンドのユーザー

deleteFriendByUserId

同期処理

from gs2_friend_client.request import DeleteFriendByUserIdRequest
from gs2_friend_client.result import DeleteFriendByUserIdResult

result = client.delete_friend_by_user_id(
    DeleteFriendByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DeleteFriendByUserIdRequest
import io.gs2.friend.result.DeleteFriendByUserIdResult

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

非同期処理

from gs2_friend_client.request import DeleteFriendByUserIdRequest
from gs2_friend_client.result import DeleteFriendByUserIdResult

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

result = client.delete_friend_by_user_id_async(
    DeleteFriendByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003'),
    callback
)
import io.gs2.friend.request.DeleteFriendByUserIdRequest
import io.gs2.friend.result.DeleteFriendByUserIdResult

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

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

ユーザーIDを指定してフレンドを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
targetUserId string true ユーザーID
パラメータ データ型 説明
item FriendUser フレンドのユーザー

deleteNamespace

同期処理

from gs2_friend_client.request import DeleteNamespaceRequest
from gs2_friend_client.result import DeleteNamespaceResult

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

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

非同期処理

from gs2_friend_client.request import DeleteNamespaceRequest
from gs2_friend_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('namespaceId-0001'),
    callback
)
import io.gs2.friend.request.DeleteNamespaceRequest
import io.gs2.friend.result.DeleteNamespaceResult

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

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

ネームスペースを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace 削除したネームスペース

deleteProfileByUserId

同期処理

from gs2_friend_client.request import DeleteProfileByUserIdRequest
from gs2_friend_client.result import DeleteProfileByUserIdResult

result = client.delete_profile_by_user_id(
    DeleteProfileByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DeleteProfileByUserIdRequest
import io.gs2.friend.result.DeleteProfileByUserIdResult

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

非同期処理

from gs2_friend_client.request import DeleteProfileByUserIdRequest
from gs2_friend_client.result import DeleteProfileByUserIdResult

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

result = client.delete_profile_by_user_id_async(
    DeleteProfileByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.friend.request.DeleteProfileByUserIdRequest
import io.gs2.friend.result.DeleteProfileByUserIdResult

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

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

プロフィールを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
パラメータ データ型 説明

deleteRequest

同期処理

from gs2_friend_client.request import DeleteRequestRequest
from gs2_friend_client.result import DeleteRequestResult

result = client.delete_request(
    DeleteRequestRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DeleteRequestRequest
import io.gs2.friend.result.DeleteRequestResult

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

非同期処理

from gs2_friend_client.request import DeleteRequestRequest
from gs2_friend_client.result import DeleteRequestResult

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

result = client.delete_request_async(
    DeleteRequestRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002'),
    callback
)
import io.gs2.friend.request.DeleteRequestRequest
import io.gs2.friend.result.DeleteRequestResult

result = client.deleteRequest(
    DeleteRequestRequest()
        .withNamespaceName("namespaceId-0002")
        .withTargetUserId("user-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

フレンドリクエストを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
targetUserId string true リクエストの送信先ユーザID
パラメータ データ型 説明
item FriendRequest 削除したフレンドリクエスト

deleteRequestByUserId

同期処理

from gs2_friend_client.request import DeleteRequestByUserIdRequest
from gs2_friend_client.result import DeleteRequestByUserIdResult

result = client.delete_request_by_user_id(
    DeleteRequestByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DeleteRequestByUserIdRequest
import io.gs2.friend.result.DeleteRequestByUserIdResult

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

非同期処理

from gs2_friend_client.request import DeleteRequestByUserIdRequest
from gs2_friend_client.result import DeleteRequestByUserIdResult

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

result = client.delete_request_by_user_id_async(
    DeleteRequestByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003'),
    callback
)
import io.gs2.friend.request.DeleteRequestByUserIdRequest
import io.gs2.friend.result.DeleteRequestByUserIdResult

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

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

ユーザーIDを指定してフレンドリクエストを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true リクエストの送信元ユーザID
targetUserId string true リクエストの送信先ユーザID
パラメータ データ型 説明
item FriendRequest 削除したフレンドリクエスト

describeFollows

同期処理

from gs2_friend_client.request import DescribeFollowsRequest
from gs2_friend_client.result import DescribeFollowsResult

result = client.describe_follows(
    DescribeFollowsRequest()\
        .with_namespace_name('namespaceId-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DescribeFollowsRequest
import io.gs2.friend.result.DescribeFollowsResult

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

非同期処理

from gs2_friend_client.request import DescribeFollowsRequest
from gs2_friend_client.result import DescribeFollowsResult

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

result = client.describe_follows_async(
    DescribeFollowsRequest()\
        .with_namespace_name('namespaceId-0002'),
    callback
)
import io.gs2.friend.request.DescribeFollowsRequest
import io.gs2.friend.result.DescribeFollowsResult

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

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

フォローの一覧取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
withProfile boolean true プロフィールも一緒に取得するか
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[FollowUser] フォローしているユーザーのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeFollowsByUserId

同期処理

from gs2_friend_client.request import DescribeFollowsByUserIdRequest
from gs2_friend_client.result import DescribeFollowsByUserIdResult

result = client.describe_follows_by_user_id(
    DescribeFollowsByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DescribeFollowsByUserIdRequest
import io.gs2.friend.result.DescribeFollowsByUserIdResult

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

非同期処理

from gs2_friend_client.request import DescribeFollowsByUserIdRequest
from gs2_friend_client.result import DescribeFollowsByUserIdResult

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

result = client.describe_follows_by_user_id_async(
    DescribeFollowsByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.friend.request.DescribeFollowsByUserIdRequest
import io.gs2.friend.result.DescribeFollowsByUserIdResult

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

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

ユーザーIDを指定してフォローの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
withProfile boolean true プロフィールも一緒に取得するか
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[FollowUser] フォローしているユーザーのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeFriends

同期処理

from gs2_friend_client.request import DescribeFriendsRequest
from gs2_friend_client.result import DescribeFriendsResult

result = client.describe_friends(
    DescribeFriendsRequest()\
        .with_namespace_name('namespaceId-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DescribeFriendsRequest
import io.gs2.friend.result.DescribeFriendsResult

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

非同期処理

from gs2_friend_client.request import DescribeFriendsRequest
from gs2_friend_client.result import DescribeFriendsResult

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

result = client.describe_friends_async(
    DescribeFriendsRequest()\
        .with_namespace_name('namespaceId-0002'),
    callback
)
import io.gs2.friend.request.DescribeFriendsRequest
import io.gs2.friend.result.DescribeFriendsResult

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

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

フレンドを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
withProfile boolean true プロフィールも一緒に取得するか
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[FriendUser] フレンドのユーザーのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeFriendsByUserId

同期処理

from gs2_friend_client.request import DescribeFriendsByUserIdRequest
from gs2_friend_client.result import DescribeFriendsByUserIdResult

result = client.describe_friends_by_user_id(
    DescribeFriendsByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DescribeFriendsByUserIdRequest
import io.gs2.friend.result.DescribeFriendsByUserIdResult

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

非同期処理

from gs2_friend_client.request import DescribeFriendsByUserIdRequest
from gs2_friend_client.result import DescribeFriendsByUserIdResult

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

result = client.describe_friends_by_user_id_async(
    DescribeFriendsByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.friend.request.DescribeFriendsByUserIdRequest
import io.gs2.friend.result.DescribeFriendsByUserIdResult

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

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

ユーザーIDを指定してフレンドを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
withProfile boolean true プロフィールも一緒に取得するか
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[FriendUser] フレンドのユーザーのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeNamespaces

同期処理

from gs2_friend_client.request import DescribeNamespacesRequest
from gs2_friend_client.result import DescribeNamespacesResult

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

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

非同期処理

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

describeProfiles

同期処理

from gs2_friend_client.request import DescribeProfilesRequest
from gs2_friend_client.result import DescribeProfilesResult

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

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

非同期処理

from gs2_friend_client.request import DescribeProfilesRequest
from gs2_friend_client.result import DescribeProfilesResult

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

result = client.describe_profiles_async(
    DescribeProfilesRequest()\
    callback
)
import io.gs2.friend.request.DescribeProfilesRequest
import io.gs2.friend.result.DescribeProfilesResult

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

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

ユーザーIDを指定してプロフィールの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Profile] プロフィールのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeReceiveRequests

同期処理

from gs2_friend_client.request import DescribeReceiveRequestsRequest
from gs2_friend_client.result import DescribeReceiveRequestsResult

result = client.describe_receive_requests(
    DescribeReceiveRequestsRequest()\
        .with_namespace_name('namespaceId-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DescribeReceiveRequestsRequest
import io.gs2.friend.result.DescribeReceiveRequestsResult

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

非同期処理

from gs2_friend_client.request import DescribeReceiveRequestsRequest
from gs2_friend_client.result import DescribeReceiveRequestsResult

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

result = client.describe_receive_requests_async(
    DescribeReceiveRequestsRequest()\
        .with_namespace_name('namespaceId-0002'),
    callback
)
import io.gs2.friend.request.DescribeReceiveRequestsRequest
import io.gs2.friend.result.DescribeReceiveRequestsResult

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

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

受信したフレンドリクエストの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[FriendRequest] フレンドリクエストのリスト

describeReceiveRequestsByUserId

同期処理

from gs2_friend_client.request import DescribeReceiveRequestsByUserIdRequest
from gs2_friend_client.result import DescribeReceiveRequestsByUserIdResult

result = client.describe_receive_requests_by_user_id(
    DescribeReceiveRequestsByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DescribeReceiveRequestsByUserIdRequest
import io.gs2.friend.result.DescribeReceiveRequestsByUserIdResult

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

非同期処理

from gs2_friend_client.request import DescribeReceiveRequestsByUserIdRequest
from gs2_friend_client.result import DescribeReceiveRequestsByUserIdResult

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

result = client.describe_receive_requests_by_user_id_async(
    DescribeReceiveRequestsByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.friend.request.DescribeReceiveRequestsByUserIdRequest
import io.gs2.friend.result.DescribeReceiveRequestsByUserIdResult

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

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

ユーザーIDを指定して受信したフレンドリクエストの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
パラメータ データ型 説明
items list[FriendRequest] フレンドリクエストのリスト

describeSendRequests

同期処理

from gs2_friend_client.request import DescribeSendRequestsRequest
from gs2_friend_client.result import DescribeSendRequestsResult

result = client.describe_send_requests(
    DescribeSendRequestsRequest()\
        .with_namespace_name('namespaceId-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DescribeSendRequestsRequest
import io.gs2.friend.result.DescribeSendRequestsResult

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

非同期処理

from gs2_friend_client.request import DescribeSendRequestsRequest
from gs2_friend_client.result import DescribeSendRequestsResult

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

result = client.describe_send_requests_async(
    DescribeSendRequestsRequest()\
        .with_namespace_name('namespaceId-0002'),
    callback
)
import io.gs2.friend.request.DescribeSendRequestsRequest
import io.gs2.friend.result.DescribeSendRequestsResult

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

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

送信したフレンドリクエストの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[FriendRequest] フレンドリクエストのリスト

describeSendRequestsByUserId

同期処理

from gs2_friend_client.request import DescribeSendRequestsByUserIdRequest
from gs2_friend_client.result import DescribeSendRequestsByUserIdResult

result = client.describe_send_requests_by_user_id(
    DescribeSendRequestsByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.DescribeSendRequestsByUserIdRequest
import io.gs2.friend.result.DescribeSendRequestsByUserIdResult

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

非同期処理

from gs2_friend_client.request import DescribeSendRequestsByUserIdRequest
from gs2_friend_client.result import DescribeSendRequestsByUserIdResult

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

result = client.describe_send_requests_by_user_id_async(
    DescribeSendRequestsByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.friend.request.DescribeSendRequestsByUserIdRequest
import io.gs2.friend.result.DescribeSendRequestsByUserIdResult

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

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

ユーザーIDを指定して送信したフレンドリクエストの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
パラメータ データ型 説明
items list[FriendRequest] フレンドリクエストのリスト

follow

同期処理

from gs2_friend_client.request import FollowRequest
from gs2_friend_client.result import FollowResult

result = client.follow(
    FollowRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.FollowRequest
import io.gs2.friend.result.FollowResult

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

非同期処理

from gs2_friend_client.request import FollowRequest
from gs2_friend_client.result import FollowResult

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

result = client.follow_async(
    FollowRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002'),
    callback
)
import io.gs2.friend.request.FollowRequest
import io.gs2.friend.result.FollowResult

result = client.follow(
    FollowRequest()
        .withNamespaceName("namespaceId-0002")
        .withTargetUserId("user-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

フォロー

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
targetUserId string true フォローされるユーザID
パラメータ データ型 説明
item FollowUser フォローしたユーザ

followByUserId

同期処理

from gs2_friend_client.request import FollowByUserIdRequest
from gs2_friend_client.result import FollowByUserIdResult

result = client.follow_by_user_id(
    FollowByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.FollowByUserIdRequest
import io.gs2.friend.result.FollowByUserIdResult

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

非同期処理

from gs2_friend_client.request import FollowByUserIdRequest
from gs2_friend_client.result import FollowByUserIdResult

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

result = client.follow_by_user_id_async(
    FollowByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003'),
    callback
)
import io.gs2.friend.request.FollowByUserIdRequest
import io.gs2.friend.result.FollowByUserIdResult

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

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

ユーザーIDを指定してフォロー

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true フォローするユーザID
targetUserId string true フォローされるユーザID
パラメータ データ型 説明
item FollowUser フォローしたユーザ

getFollow

同期処理

from gs2_friend_client.request import GetFollowRequest
from gs2_friend_client.result import GetFollowResult

result = client.get_follow(
    GetFollowRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.GetFollowRequest
import io.gs2.friend.result.GetFollowResult

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

非同期処理

from gs2_friend_client.request import GetFollowRequest
from gs2_friend_client.result import GetFollowResult

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

result = client.get_follow_async(
    GetFollowRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002'),
    callback
)
import io.gs2.friend.request.GetFollowRequest
import io.gs2.friend.result.GetFollowResult

result = client.getFollow(
    GetFollowRequest()
        .withNamespaceName("namespaceId-0002")
        .withTargetUserId("user-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

フォローを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
targetUserId string true フォローされているユーザID
withProfile boolean true プロフィールも一緒に取得するか
パラメータ データ型 説明
item FollowUser フォローしているユーザー

getFollowByUserId

同期処理

from gs2_friend_client.request import GetFollowByUserIdRequest
from gs2_friend_client.result import GetFollowByUserIdResult

result = client.get_follow_by_user_id(
    GetFollowByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.GetFollowByUserIdRequest
import io.gs2.friend.result.GetFollowByUserIdResult

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

非同期処理

from gs2_friend_client.request import GetFollowByUserIdRequest
from gs2_friend_client.result import GetFollowByUserIdResult

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

result = client.get_follow_by_user_id_async(
    GetFollowByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003'),
    callback
)
import io.gs2.friend.request.GetFollowByUserIdRequest
import io.gs2.friend.result.GetFollowByUserIdResult

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

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

ユーザーIDを指定してフォローを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true フォローしているユーザID
targetUserId string true フォローされているユーザID
withProfile boolean true プロフィールも一緒に取得するか
パラメータ データ型 説明
item FollowUser フォローしているユーザー

getFriend

同期処理

from gs2_friend_client.request import GetFriendRequest
from gs2_friend_client.result import GetFriendResult

result = client.get_friend(
    GetFriendRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.GetFriendRequest
import io.gs2.friend.result.GetFriendResult

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

非同期処理

from gs2_friend_client.request import GetFriendRequest
from gs2_friend_client.result import GetFriendResult

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

result = client.get_friend_async(
    GetFriendRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002'),
    callback
)
import io.gs2.friend.request.GetFriendRequest
import io.gs2.friend.result.GetFriendResult

result = client.getFriend(
    GetFriendRequest()
        .withNamespaceName("namespaceId-0002")
        .withTargetUserId("user-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

フレンドを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
targetUserId string true ユーザーID
withProfile boolean true プロフィールも一緒に取得するか
パラメータ データ型 説明
item FriendUser フレンドのユーザー

getFriendByUserId

同期処理

from gs2_friend_client.request import GetFriendByUserIdRequest
from gs2_friend_client.result import GetFriendByUserIdResult

result = client.get_friend_by_user_id(
    GetFriendByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.GetFriendByUserIdRequest
import io.gs2.friend.result.GetFriendByUserIdResult

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

非同期処理

from gs2_friend_client.request import GetFriendByUserIdRequest
from gs2_friend_client.result import GetFriendByUserIdResult

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

result = client.get_friend_by_user_id_async(
    GetFriendByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003'),
    callback
)
import io.gs2.friend.request.GetFriendByUserIdRequest
import io.gs2.friend.result.GetFriendByUserIdResult

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

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

ユーザーIDを指定してフレンドを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
targetUserId string true ユーザーID
withProfile boolean true プロフィールも一緒に取得するか
パラメータ データ型 説明
item FriendUser フレンドのユーザー

getNamespace

同期処理

from gs2_friend_client.request import GetNamespaceRequest
from gs2_friend_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_friend_client.request import GetNamespaceRequest
from gs2_friend_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('namespaceId-0001'),
    callback
)
import io.gs2.friend.request.GetNamespaceRequest
import io.gs2.friend.result.GetNamespaceResult

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

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

ネームスペースを取得

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

getNamespaceStatus

同期処理

from gs2_friend_client.request import GetNamespaceStatusRequest
from gs2_friend_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_friend_client.request import GetNamespaceStatusRequest
from gs2_friend_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('namespaceId-0001'),
    callback
)
import io.gs2.friend.request.GetNamespaceStatusRequest
import io.gs2.friend.result.GetNamespaceStatusResult

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

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

ネームスペースを取得

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

getProfile

同期処理

from gs2_friend_client.request import GetProfileRequest
from gs2_friend_client.result import GetProfileResult

result = client.get_profile(
    GetProfileRequest()\
        .with_namespace_name('namespaceId-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.GetProfileRequest
import io.gs2.friend.result.GetProfileResult

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

非同期処理

from gs2_friend_client.request import GetProfileRequest
from gs2_friend_client.result import GetProfileResult

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

result = client.get_profile_async(
    GetProfileRequest()\
        .with_namespace_name('namespaceId-0002'),
    callback
)
import io.gs2.friend.request.GetProfileRequest
import io.gs2.friend.result.GetProfileResult

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

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

プロフィールを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Profile プロフィール

getProfileByUserId

同期処理

from gs2_friend_client.request import GetProfileByUserIdRequest
from gs2_friend_client.result import GetProfileByUserIdResult

result = client.get_profile_by_user_id(
    GetProfileByUserIdRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.GetProfileByUserIdRequest
import io.gs2.friend.result.GetProfileByUserIdResult

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

非同期処理

from gs2_friend_client.request import GetProfileByUserIdRequest
from gs2_friend_client.result import GetProfileByUserIdResult

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

result = client.get_profile_by_user_id_async(
    GetProfileByUserIdRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.friend.request.GetProfileByUserIdRequest
import io.gs2.friend.result.GetProfileByUserIdResult

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

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

ユーザーIDを指定してプロフィールを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
パラメータ データ型 説明
item Profile プロフィール

getPublicProfile

同期処理

from gs2_friend_client.request import GetPublicProfileRequest
from gs2_friend_client.result import GetPublicProfileResult

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

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

非同期処理

from gs2_friend_client.request import GetPublicProfileRequest
from gs2_friend_client.result import GetPublicProfileResult

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

result = client.get_public_profile_async(
    GetPublicProfileRequest()\
    callback
)
import io.gs2.friend.request.GetPublicProfileRequest
import io.gs2.friend.result.GetPublicProfileResult

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

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

公開プロフィールを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
パラメータ データ型 説明
item PublicProfile 公開プロフィール

getReceiveRequest

同期処理

from gs2_friend_client.request import GetReceiveRequestRequest
from gs2_friend_client.result import GetReceiveRequestResult

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

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

非同期処理

from gs2_friend_client.request import GetReceiveRequestRequest
from gs2_friend_client.result import GetReceiveRequestResult

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

result = client.get_receive_request_async(
    GetReceiveRequestRequest()\
    callback
)
import io.gs2.friend.request.GetReceiveRequestRequest
import io.gs2.friend.result.GetReceiveRequestResult

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

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

受信したフレンドリクエストを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
fromUserId string true ユーザーID
パラメータ データ型 説明
item FriendRequest フレンドリクエスト

getReceiveRequestByUserId

同期処理

from gs2_friend_client.request import GetReceiveRequestByUserIdRequest
from gs2_friend_client.result import GetReceiveRequestByUserIdResult

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

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

非同期処理

from gs2_friend_client.request import GetReceiveRequestByUserIdRequest
from gs2_friend_client.result import GetReceiveRequestByUserIdResult

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

result = client.get_receive_request_by_user_id_async(
    GetReceiveRequestByUserIdRequest()\
    callback
)
import io.gs2.friend.request.GetReceiveRequestByUserIdRequest
import io.gs2.friend.result.GetReceiveRequestByUserIdResult

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

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

ユーザーIDを指定して受信したフレンドリクエストを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
fromUserId string true ユーザーID
パラメータ データ型 説明
item FriendRequest フレンドリクエスト

getSendRequest

同期処理

from gs2_friend_client.request import GetSendRequestRequest
from gs2_friend_client.result import GetSendRequestResult

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

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

非同期処理

from gs2_friend_client.request import GetSendRequestRequest
from gs2_friend_client.result import GetSendRequestResult

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

result = client.get_send_request_async(
    GetSendRequestRequest()\
    callback
)
import io.gs2.friend.request.GetSendRequestRequest
import io.gs2.friend.result.GetSendRequestResult

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

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

送信したフレンドリクエストを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
targetUserId string true ユーザーID
パラメータ データ型 説明
item FriendRequest フレンドリクエスト

getSendRequestByUserId

同期処理

from gs2_friend_client.request import GetSendRequestByUserIdRequest
from gs2_friend_client.result import GetSendRequestByUserIdResult

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

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

非同期処理

from gs2_friend_client.request import GetSendRequestByUserIdRequest
from gs2_friend_client.result import GetSendRequestByUserIdResult

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

result = client.get_send_request_by_user_id_async(
    GetSendRequestByUserIdRequest()\
    callback
)
import io.gs2.friend.request.GetSendRequestByUserIdRequest
import io.gs2.friend.result.GetSendRequestByUserIdResult

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

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

ユーザーIDを指定して送信したフレンドリクエストを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
targetUserId string true ユーザーID
パラメータ データ型 説明
item FriendRequest フレンドリクエスト

rejectRequest

同期処理

from gs2_friend_client.request import RejectRequestRequest
from gs2_friend_client.result import RejectRequestResult

result = client.reject_request(
    RejectRequestRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_from_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.RejectRequestRequest
import io.gs2.friend.result.RejectRequestResult

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

非同期処理

from gs2_friend_client.request import RejectRequestRequest
from gs2_friend_client.result import RejectRequestResult

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

result = client.reject_request_async(
    RejectRequestRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_from_user_id('user-0002'),
    callback
)
import io.gs2.friend.request.RejectRequestRequest
import io.gs2.friend.result.RejectRequestResult

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

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

フレンドリクエストを拒否

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
fromUserId string true フレンドリクエストを送信したユーザID
パラメータ データ型 説明
item FriendRequest 拒否したフレンドリクエスト

rejectRequestByUserId

同期処理

from gs2_friend_client.request import RejectRequestByUserIdRequest
from gs2_friend_client.result import RejectRequestByUserIdResult

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

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

非同期処理

from gs2_friend_client.request import RejectRequestByUserIdRequest
from gs2_friend_client.result import RejectRequestByUserIdResult

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

result = client.reject_request_by_user_id_async(
    RejectRequestByUserIdRequest()\
    callback
)
import io.gs2.friend.request.RejectRequestByUserIdRequest
import io.gs2.friend.result.RejectRequestByUserIdResult

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

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

ユーザーIDを指定してフレンドリクエストを拒否

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true フレンドリクエストを受け取ったユーザID
fromUserId string true フレンドリクエストを送信したユーザID
パラメータ データ型 説明
item FriendRequest 拒否したフレンドリクエスト

sendRequest

同期処理

from gs2_friend_client.request import SendRequestRequest
from gs2_friend_client.result import SendRequestResult

result = client.send_request(
    SendRequestRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.SendRequestRequest
import io.gs2.friend.result.SendRequestResult

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

非同期処理

from gs2_friend_client.request import SendRequestRequest
from gs2_friend_client.result import SendRequestResult

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

result = client.send_request_async(
    SendRequestRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002'),
    callback
)
import io.gs2.friend.request.SendRequestRequest
import io.gs2.friend.result.SendRequestResult

result = client.sendRequest(
    SendRequestRequest()
        .withNamespaceName("namespaceId-0002")
        .withTargetUserId("user-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

フレンドリクエストを送信

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
targetUserId string true リクエストの送信先ユーザID
パラメータ データ型 説明
item FriendRequest 送信したフレンドリクエスト

sendRequestByUserId

同期処理

from gs2_friend_client.request import SendRequestByUserIdRequest
from gs2_friend_client.result import SendRequestByUserIdResult

result = client.send_request_by_user_id(
    SendRequestByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.SendRequestByUserIdRequest
import io.gs2.friend.result.SendRequestByUserIdResult

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

非同期処理

from gs2_friend_client.request import SendRequestByUserIdRequest
from gs2_friend_client.result import SendRequestByUserIdResult

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

result = client.send_request_by_user_id_async(
    SendRequestByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003'),
    callback
)
import io.gs2.friend.request.SendRequestByUserIdRequest
import io.gs2.friend.result.SendRequestByUserIdResult

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

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

ユーザーIDを指定してフレンドリクエストを送信

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true リクエストの送信元ユーザID
targetUserId string true リクエストの送信先ユーザID
パラメータ データ型 説明
item FriendRequest 送信したフレンドリクエスト

unfollow

同期処理

from gs2_friend_client.request import UnfollowRequest
from gs2_friend_client.result import UnfollowResult

result = client.unfollow(
    UnfollowRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.UnfollowRequest
import io.gs2.friend.result.UnfollowResult

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

非同期処理

from gs2_friend_client.request import UnfollowRequest
from gs2_friend_client.result import UnfollowResult

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

result = client.unfollow_async(
    UnfollowRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_target_user_id('user-0002'),
    callback
)
import io.gs2.friend.request.UnfollowRequest
import io.gs2.friend.result.UnfollowResult

result = client.unfollow(
    UnfollowRequest()
        .withNamespaceName("namespaceId-0002")
        .withTargetUserId("user-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

アンフォロー

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
targetUserId string true フォローされているユーザID
パラメータ データ型 説明
item FollowUser アンフォローしたユーザ

unfollowByUserId

同期処理

from gs2_friend_client.request import UnfollowByUserIdRequest
from gs2_friend_client.result import UnfollowByUserIdResult

result = client.unfollow_by_user_id(
    UnfollowByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.UnfollowByUserIdRequest
import io.gs2.friend.result.UnfollowByUserIdResult

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

非同期処理

from gs2_friend_client.request import UnfollowByUserIdRequest
from gs2_friend_client.result import UnfollowByUserIdResult

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

result = client.unfollow_by_user_id_async(
    UnfollowByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_target_user_id('user-0003'),
    callback
)
import io.gs2.friend.request.UnfollowByUserIdRequest
import io.gs2.friend.result.UnfollowByUserIdResult

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

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

ユーザーIDを指定してアンフォロー

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true フォローしているユーザID
targetUserId string true フォローされているユーザID
パラメータ データ型 説明
item FollowUser アンフォローしたユーザ

updateNamespace

同期処理

from gs2_friend_client.request import UpdateNamespaceRequest
from gs2_friend_client.result import UpdateNamespaceResult

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

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

非同期処理

from gs2_friend_client.request import UpdateNamespaceRequest
from gs2_friend_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('namespaceId-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.friend.request.UpdateNamespaceRequest
import io.gs2.friend.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespaceId-0001")
        .withDescription("description1")
        .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 ネームスペースの説明
followScript ScriptSetting false フォローされたときに実行するスクリプト
unfollowScript ScriptSetting false アンフォローされたときに実行するスクリプト
sendRequestScript ScriptSetting false フレンドリクエストを発行したときに実行するスクリプト
cancelRequestScript ScriptSetting false フレンドリクエストをキャンセルしたときに実行するスクリプト
acceptRequestScript ScriptSetting false フレンドリクエストを承諾したときに実行するスクリプト
rejectRequestScript ScriptSetting false フレンドリクエストを拒否したときに実行するスクリプト
deleteFriendScript ScriptSetting false フレンドを削除したときに実行するスクリプト
updateProfileScript ScriptSetting false プロフィールを更新したときに実行するスクリプト
followNotification NotificationSetting false フォローされたときのプッシュ通知
receiveRequestNotification NotificationSetting false フレンドリクエストが届いたときのプッシュ通知
acceptRequestNotification NotificationSetting false フレンドリクエストが承認されたときのプッシュ通知
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

updateProfile

同期処理

from gs2_friend_client.request import UpdateProfileRequest
from gs2_friend_client.result import UpdateProfileResult

result = client.update_profile(
    UpdateProfileRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_public_profile('public')\
        .with_follower_profile('follower')\
        .with_friend_profile('friend')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.UpdateProfileRequest
import io.gs2.friend.result.UpdateProfileResult

result = client.updateProfile(
    UpdateProfileRequest()
        .withNamespaceName("namespaceId-0002")
        .withPublicProfile("public")
        .withFollowerProfile("follower")
        .withFriendProfile("friend")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_friend_client.request import UpdateProfileRequest
from gs2_friend_client.result import UpdateProfileResult

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

result = client.update_profile_async(
    UpdateProfileRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_public_profile('public')\
        .with_follower_profile('follower')\
        .with_friend_profile('friend'),
    callback
)
import io.gs2.friend.request.UpdateProfileRequest
import io.gs2.friend.result.UpdateProfileResult

result = client.updateProfile(
    UpdateProfileRequest()
        .withNamespaceName("namespaceId-0002")
        .withPublicProfile("public")
        .withFollowerProfile("follower")
        .withFriendProfile("friend"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

プロフィールを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
publicProfile string false 公開されるプロフィール
followerProfile string false フォロワー向けに公開されるプロフィール
friendProfile string false フレンド向けに公開されるプロフィール
パラメータ データ型 説明
item Profile 更新したプロフィール

updateProfileByUserId

同期処理

from gs2_friend_client.request import UpdateProfileByUserIdRequest
from gs2_friend_client.result import UpdateProfileByUserIdResult

result = client.update_profile_by_user_id(
    UpdateProfileByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_public_profile('public')\
        .with_follower_profile('follower')\
        .with_friend_profile('friend')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.friend.request.UpdateProfileByUserIdRequest
import io.gs2.friend.result.UpdateProfileByUserIdResult

result = client.updateProfileByUserId(
    UpdateProfileByUserIdRequest()
        .withNamespaceName("namespaceId-0002")
        .withUserId("user-0002")
        .withPublicProfile("public")
        .withFollowerProfile("follower")
        .withFriendProfile("friend")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_friend_client.request import UpdateProfileByUserIdRequest
from gs2_friend_client.result import UpdateProfileByUserIdResult

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

result = client.update_profile_by_user_id_async(
    UpdateProfileByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0002')\
        .with_public_profile('public')\
        .with_follower_profile('follower')\
        .with_friend_profile('friend'),
    callback
)
import io.gs2.friend.request.UpdateProfileByUserIdRequest
import io.gs2.friend.result.UpdateProfileByUserIdResult

result = client.updateProfileByUserId(
    UpdateProfileByUserIdRequest()
        .withNamespaceName("namespaceId-0002")
        .withUserId("user-0002")
        .withPublicProfile("public")
        .withFollowerProfile("follower")
        .withFriendProfile("friend"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザーIDを指定してプロフィールを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string true ユーザーID
publicProfile string false 公開されるプロフィール
followerProfile string false フォロワー向けに公開されるプロフィール
friendProfile string false フレンド向けに公開されるプロフィール
パラメータ データ型 説明
item Profile 更新したプロフィール

GS2-Script トリガーイベント

FollowTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
follow_user = args['followUser']  -- type: FollowUser

result = {
    permit=  -- type: boolean
}

フォロー時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
followUser FollowUser フォローしているユーザー
パラメータ データ型 説明
permit boolean フォロー を許可するか

FollowDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
follow_user = args['followUser']  -- type: FollowUser

result = {
}

フォロー完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
followUser FollowUser フォローしているユーザー
パラメータ データ型 説明

UnfollowTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
follow_user = args['followUser']  -- type: FollowUser

result = {
    permit=  -- type: boolean
}

アンフォロー時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
followUser FollowUser フォローしているユーザー
パラメータ データ型 説明
permit boolean アンフォロー を許可するか

UnfollowDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
follow_user = args['followUser']  -- type: FollowUser

result = {
}

アンフォロー完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
followUser FollowUser フォローしているユーザー
パラメータ データ型 説明

SendRequestTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
friend_request = args['friendRequest']  -- type: FriendRequest

result = {
    permit=  -- type: boolean
}

フレンドリクエストを発行時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
friendRequest FriendRequest フレンドリクエスト
パラメータ データ型 説明
permit boolean フレンドリクエストの発行 を許可するか

SendRequestDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
friend_request = args['friendRequest']  -- type: FriendRequest

result = {
}

フレンドリクエストを発行完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
friendRequest FriendRequest フレンドリクエスト
パラメータ データ型 説明

CancelRequestTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
friend_request = args['friendRequest']  -- type: FriendRequest

result = {
    permit=  -- type: boolean
}

フレンドリクエストのキャンセル時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
friendRequest FriendRequest フレンドリクエスト
パラメータ データ型 説明
permit boolean フレンドリクエストのキャンセル を許可するか

CancelRequestDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
friend_request = args['friendRequest']  -- type: FriendRequest

result = {
}

フレンドリクエストのキャンセル完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
friendRequest FriendRequest フレンドリクエスト
パラメータ データ型 説明

AcceptRequestTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
friend_request = args['friendRequest']  -- type: FriendRequest

result = {
    permit=  -- type: boolean
}

フレンドリクエストの承諾時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
friendRequest FriendRequest フレンドリクエスト
パラメータ データ型 説明
permit boolean フレンドリクエストの承諾 を許可するか

AcceptRequestDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
friend_request = args['friendRequest']  -- type: FriendRequest

result = {
}

フレンドリクエストの承諾完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
friendRequest FriendRequest フレンドリクエスト
パラメータ データ型 説明

RejectRequestTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
friend_request = args['friendRequest']  -- type: FriendRequest

result = {
    permit=  -- type: boolean
}

フレンドリクエストの拒否時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
friendRequest FriendRequest フレンドリクエスト
パラメータ データ型 説明
permit boolean フレンドリクエストの拒否 を許可するか

RejectRequestDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
friend_request = args['friendRequest']  -- type: FriendRequest

result = {
}

フレンドリクエストの拒否完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
friendRequest FriendRequest フレンドリクエスト
パラメータ データ型 説明

DeleteFriendTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
friend_user = args['friendUser']  -- type: FriendUser

result = {
    permit=  -- type: boolean
}

フレンドの削除時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
friendUser FriendUser フレンドのユーザー
パラメータ データ型 説明
permit boolean フレンドの削除 を許可するか

DeleteFriendDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
friend_user = args['friendUser']  -- type: FriendUser

result = {
}

フレンドの削除完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
friendUser FriendUser フレンドのユーザー
パラメータ データ型 説明

UpdateProfileTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
profile = args['profile']  -- type: Profile

result = {
    permit=  -- type: boolean
}

プロフィール更新時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
profile Profile プロフィール
パラメータ データ型 説明
permit boolean プロフィール更新 を許可するか

UpdateProfileDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
profile = args['profile']  -- type: Profile

result = {
}

プロフィール更新完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
profile Profile プロフィール
パラメータ データ型 説明

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

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

GS2-Friend の制限・制約

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