API Reference of GS2-Friend SDK

Model

Namespace

Namespace is a mechanism that allows multiple uses of the same service for different purposes within a single project. Basically, GS2 services have a layer called namespace, and different namespaces are treated as completely different data spaces, even for the same service.

Therefore, it is necessary to create a namespace before starting to use each service.

	Type	Require	Default	Limitation	Description
namespaceId	string	✓		~ 1024 chars	Namespace GRN
name	string	✓		~ 128 chars	Namespace name
description	string			~ 1024 chars	Description
followScript	ScriptSetting				Script to run when followed
unfollowScript	ScriptSetting				Script to run when unfollowed
sendRequestScript	ScriptSetting				Script to run when a friend request is issued
cancelRequestScript	ScriptSetting				Script to execute when a friend request is canceled
acceptRequestScript	ScriptSetting				Script to run when a friend request is accepted
rejectRequestScript	ScriptSetting				Script to execute when a friend request is rejected
deleteFriendScript	ScriptSetting				Script to run when a friend is deleted
updateProfileScript	ScriptSetting				Script to run when you update your profile
followNotification	NotificationSetting				Push notification when you are followed
receiveRequestNotification	NotificationSetting	✓			Push notification when a friend request is received
cancelRequestNotification	NotificationSetting	✓			Push notification when a received friend request is canceled
acceptRequestNotification	NotificationSetting	✓			Push notification when a friend request is approved
rejectRequestNotification	NotificationSetting	✓			Push notification when a friend request is rejected
deleteFriendNotification	NotificationSetting	✓			Push notification when a friend is deleted
logSetting	LogSetting				Log output settings
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

Profile

The profile stores information about the game player.

There are three types of profiles that can be set for each public range.

friend The information that can be viewed by those with whom a friend relationship has been established.
follow Content that can be viewed by followers.
public Content that can be viewed by anyone

	Type	Require	Default	Limitation	Description
profileId	string	✓		~ 1024 chars	Profile GRN
userId	string	✓		~ 128 chars	User Id
publicProfile	string			~ 1024 chars	Public profile
followerProfile	string			~ 1024 chars	Profile for followers
friendProfile	string			~ 1024 chars	Profile for friends
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

Follow

A follow is a unidirectional relationship between game players. The relationship is established immediately upon sending a follow request.

	Type	Require	Default	Limitation	Description
followId	string	✓		~ 1024 chars	Follow GRN
userId	string	✓		~ 128 chars	User Id
targetUserIds	List<string>			~ 1000 items	List of user IDs you are following
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

Friend

A friend is a two-way, approved relationship between game players. To establish a friend relationship, one party must send a request and the other party must approve it.

	Type	Require	Default	Limitation	Description
friendId	string	✓		~ 1024 chars	Friend GRN
userId	string	✓		~ 128 chars	User Id
targetUserIds	List<string>			~ 1000 items	User ID list of friends
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

SendBox

Send box

Sent friend requests

	Type	Require	Default	Limitation	Description
sendBoxId	string	✓		~ 1024 chars	SendBox GRN
userId	string	✓		~ 128 chars	User Id
targetUserIds	List<string>			~ 1000 items	Destination user ID list for friend requests
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

Inbox

In-box

Received friend requests

	Type	Require	Default	Limitation	Description
inboxId	string	✓		~ 1024 chars	Inbox GRN
userId	string	✓		~ 128 chars	User Id
fromUserIds	List<string>			~ 1000 items	List of user IDs who have sent friend requests
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

BlackList

Blacklist

	Type	Require	Default	Limitation	Description
blackListId	string	✓		~ 1024 chars	Blacklist GRN
userId	string	✓		~ 128 chars	User Id
targetUserIds	List<string>			~ 10000 items	Blacklist user ID list
createdAt	long	✓	Now		Datetime of creation (Unix time unit:milliseconds)
updatedAt	long	✓	Now		Datetime of last update (Unix time unit:milliseconds)
revision	long		0	~ 9223372036854775805	Revision

FollowUser

Users you are following

	Type	Require	Limitation	Description
userId	string	✓	~ 128 chars	User Id
publicProfile	string		~ 1024 chars	Public profile
followerProfile	string		~ 1024 chars	Profile for followers

FriendUser

Friend’s users

	Type	Require	Limitation	Description
userId	string	✓	~ 128 chars	User Id
publicProfile	string		~ 1024 chars	Public profile
friendProfile	string		~ 1024 chars	Profile for friends

FriendRequest

friend request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	Sender
targetUserId	string		✓		~ 128 chars	Target

SendFriendRequest

Friend request sent

This entity indicates the status of a pending friend request. This is a friend request sent by the user to another user. When the user who sent the friend request approves it, the friend request is deleted and the user is added to the friend list.

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	Sent
targetUserId	string		✓		~ 128 chars	Target

ReceiveFriendRequest

Friend request received

This entity indicates that a friend request has been accepted. This is a friend request received by the user from another user. When the user approves the friend request, the friend request is deleted and the user is added to the friend list.

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	Sent
targetUserId	string		✓		~ 128 chars	Target

PublicProfile

Profile available to everyone

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
publicProfile	string				~ 1024 chars	Public profile

ScriptSetting

Script settings

In GS2, you can associate custom scripts with microservice events and execute them. This model holds the settings for triggering script execution.

There are two main ways to execute a script: synchronous execution and asynchronous execution. Synchronous execution blocks processing until the script has finished executing. Instead, you can use the script execution result to stop the execution of the API or to tamper with the result of the API.

On the other hand, asynchronous execution does not block processing until the script has finished executing. Instead, you can use the script execution result to stop the execution of the API or to tamper with the result of the API. However, asynchronous execution does not block processing until the script has finished executing, so it is generally recommended to use asynchronous execution.

There are two types of asynchronous execution methods: GS2-Script and Amazon EventBridge. By using Amazon EventBridge, you can write processing in languages other than Lua.

	Type	Condition	Require	Default	Limitation	Description
triggerScriptId	string				~ 1024 chars	Script GRN
doneTriggerTargetType	enum { “none”, “gs2_script”, “aws” }		✓	“none”	~ 128 chars	Notification of Completion
doneTriggerScriptId	string	{doneTriggerTargetType} == “gs2_script”			~ 1024 chars	Script GRN
doneTriggerQueueNamespaceId	string	{doneTriggerTargetType} == “gs2_script”			~ 1024 chars	Namespace GRN

Enumeration type definition to specify as doneTriggerTargetType

Enumerator String Definition	Description
none	None
gs2_script	GS2-Script
aws	Amazon EventBridge

NotificationSetting

Push notification settings

This is a setting for sending push notifications when an event occurs in a GS2 microservice. The push notification here refers to the processing via the WebSocket interface provided by GS2-Gateway, and is different from the push notification of a smartphone. For example, when a matchmaking is completed or a friend request is received, the GS2-Gateway can send a push notification via the WebSocket interface, and the game client can detect the change of the state.

GS2-Gateway’s push notifications can be used to send additional processing to mobile push notifications when the destination device is offline. If you use mobile push notifications well, you may be able to realize a flow in which you can notify the player by using mobile push notifications even if you end the game during matchmaking and return to the game.

	Type	Condition	Require	Default	Limitation	Description
gatewayNamespaceId	string		✓	“grn:gs2:{region}:{ownerId}:gateway:default”	~ 1024 chars	GS2-Gateway namespace to use for push notifications
enableTransferMobileNotification	bool?			false		Forwarding to mobile push notification
sound	string	{enableTransferMobileNotification} == true			~ 1024 chars	Sound file name to be used for mobile push notifications

LogSetting

Log setting

This type manages log output settings. This type holds the identifier of the log namespace used to output log data. The log namespace ID specifies the GS2-Log namespace to aggregate and store the log data. Through this setting, API request and response log data under this namespace will be output to the target GS2-Log. GS2-Log provides logs in real time, which can be used for system monitoring, analysis, debugging, etc.

	Type	Condition	Require	Default	Limitation	Description
loggingNamespaceId	string		✓		~ 1024 chars	Namespace GRN

Methods

describeNamespaces

Get list of namespaces

Request

	Type	Condition	Require	Default	Limitation	Description
pageToken	string				~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int		✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	List<Namespace>	List of Namespace
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeNamespaces(
    &friend.DescribeNamespacesRequest {
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeNamespacesRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeNamespaces(
        (new DescribeNamespacesRequest())
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeNamespacesRequest;
import io.gs2.friend.result.DescribeNamespacesResult;

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

try {
    DescribeNamespacesResult result = client.describeNamespaces(
        new DescribeNamespacesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    List<Namespace> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeNamespacesRequest;
using Gs2.Gs2Friend.Result.DescribeNamespacesResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeNamespacesResult> asyncResult = null;
yield return client.DescribeNamespaces(
    new Gs2.Gs2Friend.Request.DescribeNamespacesRequest()
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeNamespaces(
        new Gs2Friend.DescribeNamespacesRequest()
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_namespaces(
        friend.DescribeNamespacesRequest()
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_namespaces({
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_namespaces_async({
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

createNamespace

Create a new namespace

Request

	Type	Require	Limitation	Description
name	string	✓	~ 128 chars	Namespace name
description	string		~ 1024 chars	Description
followScript	ScriptSetting			Script to run when followed
unfollowScript	ScriptSetting			Script to run when unfollowed
sendRequestScript	ScriptSetting			Script to run when a friend request is issued
cancelRequestScript	ScriptSetting			Script to execute when a friend request is canceled
acceptRequestScript	ScriptSetting			Script to run when a friend request is accepted
rejectRequestScript	ScriptSetting			Script to execute when a friend request is rejected
deleteFriendScript	ScriptSetting			Script to run when a friend is deleted
updateProfileScript	ScriptSetting			Script to run when you update your profile
followNotification	NotificationSetting			Push notification when you are followed
receiveRequestNotification	NotificationSetting	✓		Push notification when a friend request is received
cancelRequestNotification	NotificationSetting	✓		Push notification when a received friend request is canceled
acceptRequestNotification	NotificationSetting	✓		Push notification when a friend request is approved
rejectRequestNotification	NotificationSetting	✓		Push notification when a friend request is rejected
deleteFriendNotification	NotificationSetting	✓		Push notification when a friend is deleted
logSetting	LogSetting			Log output settings

Result

	Type	Description
item	Namespace	Namespace created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.CreateNamespace(
    &friend.CreateNamespaceRequest {
        Name: pointy.String("namespace1"),
        Description: nil,
        FollowScript: nil,
        UnfollowScript: nil,
        SendRequestScript: nil,
        CancelRequestScript: nil,
        AcceptRequestScript: nil,
        RejectRequestScript: nil,
        DeleteFriendScript: nil,
        UpdateProfileScript: nil,
        FollowNotification: nil,
        ReceiveRequestNotification: nil,
        CancelRequestNotification: nil,
        AcceptRequestNotification: nil,
        RejectRequestNotification: nil,
        DeleteFriendNotification: nil,
        LogSetting: &friend.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\CreateNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->createNamespace(
        (new CreateNamespaceRequest())
            ->withName(self::namespace1)
            ->withDescription(null)
            ->withFollowScript(null)
            ->withUnfollowScript(null)
            ->withSendRequestScript(null)
            ->withCancelRequestScript(null)
            ->withAcceptRequestScript(null)
            ->withRejectRequestScript(null)
            ->withDeleteFriendScript(null)
            ->withUpdateProfileScript(null)
            ->withFollowNotification(null)
            ->withReceiveRequestNotification(null)
            ->withCancelRequestNotification(null)
            ->withAcceptRequestNotification(null)
            ->withRejectRequestNotification(null)
            ->withDeleteFriendNotification(null)
            ->withLogSetting((new \Gs2\Friend\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:\namespace1"))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.CreateNamespaceRequest;
import io.gs2.friend.result.CreateNamespaceResult;

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

try {
    CreateNamespaceResult result = client.createNamespace(
        new CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withFollowScript(null)
            .withUnfollowScript(null)
            .withSendRequestScript(null)
            .withCancelRequestScript(null)
            .withAcceptRequestScript(null)
            .withRejectRequestScript(null)
            .withDeleteFriendScript(null)
            .withUpdateProfileScript(null)
            .withFollowNotification(null)
            .withReceiveRequestNotification(null)
            .withCancelRequestNotification(null)
            .withAcceptRequestNotification(null)
            .withRejectRequestNotification(null)
            .withDeleteFriendNotification(null)
            .withLogSetting(new io.gs2.friend.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.CreateNamespaceRequest;
using Gs2.Gs2Friend.Result.CreateNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.CreateNamespaceResult> asyncResult = null;
yield return client.CreateNamespace(
    new Gs2.Gs2Friend.Request.CreateNamespaceRequest()
        .WithName("namespace1")
        .WithDescription(null)
        .WithFollowScript(null)
        .WithUnfollowScript(null)
        .WithSendRequestScript(null)
        .WithCancelRequestScript(null)
        .WithAcceptRequestScript(null)
        .WithRejectRequestScript(null)
        .WithDeleteFriendScript(null)
        .WithUpdateProfileScript(null)
        .WithFollowNotification(null)
        .WithReceiveRequestNotification(null)
        .WithCancelRequestNotification(null)
        .WithAcceptRequestNotification(null)
        .WithRejectRequestNotification(null)
        .WithDeleteFriendNotification(null)
        .WithLogSetting(new Gs2.Gs2Friend.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1")),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.createNamespace(
        new Gs2Friend.CreateNamespaceRequest()
            .withName("namespace1")
            .withDescription(null)
            .withFollowScript(null)
            .withUnfollowScript(null)
            .withSendRequestScript(null)
            .withCancelRequestScript(null)
            .withAcceptRequestScript(null)
            .withRejectRequestScript(null)
            .withDeleteFriendScript(null)
            .withUpdateProfileScript(null)
            .withFollowNotification(null)
            .withReceiveRequestNotification(null)
            .withCancelRequestNotification(null)
            .withAcceptRequestNotification(null)
            .withRejectRequestNotification(null)
            .withDeleteFriendNotification(null)
            .withLogSetting(new Gs2Friend.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.create_namespace(
        friend.CreateNamespaceRequest()
            .with_name(self.hash1)
            .with_description(None)
            .with_follow_script(None)
            .with_unfollow_script(None)
            .with_send_request_script(None)
            .with_cancel_request_script(None)
            .with_accept_request_script(None)
            .with_reject_request_script(None)
            .with_delete_friend_script(None)
            .with_update_profile_script(None)
            .with_follow_notification(None)
            .with_receive_request_notification(None)
            .with_cancel_request_notification(None)
            .with_accept_request_notification(None)
            .with_reject_request_notification(None)
            .with_delete_friend_notification(None)
            .with_log_setting(
                friend.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.create_namespace({
    name="namespace1",
    description=nil,
    followScript=nil,
    unfollowScript=nil,
    sendRequestScript=nil,
    cancelRequestScript=nil,
    acceptRequestScript=nil,
    rejectRequestScript=nil,
    deleteFriendScript=nil,
    updateProfileScript=nil,
    followNotification=nil,
    receiveRequestNotification=nil,
    cancelRequestNotification=nil,
    acceptRequestNotification=nil,
    rejectRequestNotification=nil,
    deleteFriendNotification=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1",
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.create_namespace_async({
    name="namespace1",
    description=nil,
    followScript=nil,
    unfollowScript=nil,
    sendRequestScript=nil,
    cancelRequestScript=nil,
    acceptRequestScript=nil,
    rejectRequestScript=nil,
    deleteFriendScript=nil,
    updateProfileScript=nil,
    followNotification=nil,
    receiveRequestNotification=nil,
    cancelRequestNotification=nil,
    acceptRequestNotification=nil,
    rejectRequestNotification=nil,
    deleteFriendNotification=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1",
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getNamespaceStatus

Get namespace status

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name

Result

	Type	Description
status	string

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetNamespaceStatus(
    &friend.GetNamespaceStatusRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
status := result.Status

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetNamespaceStatusRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespaceStatus(
        (new GetNamespaceStatusRequest())
            ->withNamespaceName(self::namespace1)
    );
    $status = $result->getStatus();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetNamespaceStatusRequest;
import io.gs2.friend.result.GetNamespaceStatusResult;

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

try {
    GetNamespaceStatusResult result = client.getNamespaceStatus(
        new GetNamespaceStatusRequest()
            .withNamespaceName("namespace1")
    );
    String status = result.getStatus();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetNamespaceStatusRequest;
using Gs2.Gs2Friend.Result.GetNamespaceStatusResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetNamespaceStatusResult> asyncResult = null;
yield return client.GetNamespaceStatus(
    new Gs2.Gs2Friend.Request.GetNamespaceStatusRequest()
        .WithNamespaceName("namespace1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var status = result.Status;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getNamespaceStatus(
        new Gs2Friend.GetNamespaceStatusRequest()
            .withNamespaceName("namespace1")
    );
    const status = result.getStatus();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_namespace_status(
        friend.GetNamespaceStatusRequest()
            .with_namespace_name(self.hash1)
    )
    status = result.status
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_namespace_status({
    namespaceName="namespace1",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
status = result.status;

client = gs2('friend')

api_result_handler = client.get_namespace_status_async({
    namespaceName="namespace1",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
status = result.status;

getNamespace

Get namespace

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name

Result

	Type	Description
item	Namespace	Namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetNamespace(
    &friend.GetNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getNamespace(
        (new GetNamespaceRequest())
            ->withNamespaceName(self::namespace1)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetNamespaceRequest;
import io.gs2.friend.result.GetNamespaceResult;

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

try {
    GetNamespaceResult result = client.getNamespace(
        new GetNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetNamespaceRequest;
using Gs2.Gs2Friend.Result.GetNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetNamespaceResult> asyncResult = null;
yield return client.GetNamespace(
    new Gs2.Gs2Friend.Request.GetNamespaceRequest()
        .WithNamespaceName("namespace1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getNamespace(
        new Gs2Friend.GetNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_namespace(
        friend.GetNamespaceRequest()
            .with_namespace_name(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_namespace({
    namespaceName="namespace1",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_namespace_async({
    namespaceName="namespace1",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

updateNamespace

Update namespace

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
description	string		~ 1024 chars	Description
followScript	ScriptSetting			Script to run when followed
unfollowScript	ScriptSetting			Script to run when unfollowed
sendRequestScript	ScriptSetting			Script to run when a friend request is issued
cancelRequestScript	ScriptSetting			Script to execute when a friend request is canceled
acceptRequestScript	ScriptSetting			Script to run when a friend request is accepted
rejectRequestScript	ScriptSetting			Script to execute when a friend request is rejected
deleteFriendScript	ScriptSetting			Script to run when a friend is deleted
updateProfileScript	ScriptSetting			Script to run when you update your profile
followNotification	NotificationSetting			Push notification when you are followed
receiveRequestNotification	NotificationSetting	✓		Push notification when a friend request is received
cancelRequestNotification	NotificationSetting	✓		Push notification when a received friend request is canceled
acceptRequestNotification	NotificationSetting	✓		Push notification when a friend request is approved
rejectRequestNotification	NotificationSetting	✓		Push notification when a friend request is rejected
deleteFriendNotification	NotificationSetting	✓		Push notification when a friend is deleted
logSetting	LogSetting			Log output settings

Result

	Type	Description
item	Namespace	Updated namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.UpdateNamespace(
    &friend.UpdateNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
        Description: pointy.String("description1"),
        FollowScript: nil,
        UnfollowScript: nil,
        SendRequestScript: nil,
        CancelRequestScript: nil,
        AcceptRequestScript: nil,
        RejectRequestScript: nil,
        DeleteFriendScript: nil,
        UpdateProfileScript: nil,
        FollowNotification: nil,
        ReceiveRequestNotification: nil,
        CancelRequestNotification: nil,
        AcceptRequestNotification: nil,
        RejectRequestNotification: nil,
        DeleteFriendNotification: nil,
        LogSetting: &friend.LogSetting{
            LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"),
        },
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\UpdateNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateNamespace(
        (new UpdateNamespaceRequest())
            ->withNamespaceName(self::namespace1)
            ->withDescription("description1")
            ->withFollowScript(null)
            ->withUnfollowScript(null)
            ->withSendRequestScript(null)
            ->withCancelRequestScript(null)
            ->withAcceptRequestScript(null)
            ->withRejectRequestScript(null)
            ->withDeleteFriendScript(null)
            ->withUpdateProfileScript(null)
            ->withFollowNotification(null)
            ->withReceiveRequestNotification(null)
            ->withCancelRequestNotification(null)
            ->withAcceptRequestNotification(null)
            ->withRejectRequestNotification(null)
            ->withDeleteFriendNotification(null)
            ->withLogSetting((new \Gs2\Friend\Model\LogSetting())
                ->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:\namespace1"))
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.UpdateNamespaceRequest;
import io.gs2.friend.result.UpdateNamespaceResult;

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

try {
    UpdateNamespaceResult result = client.updateNamespace(
        new UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withFollowScript(null)
            .withUnfollowScript(null)
            .withSendRequestScript(null)
            .withCancelRequestScript(null)
            .withAcceptRequestScript(null)
            .withRejectRequestScript(null)
            .withDeleteFriendScript(null)
            .withUpdateProfileScript(null)
            .withFollowNotification(null)
            .withReceiveRequestNotification(null)
            .withCancelRequestNotification(null)
            .withAcceptRequestNotification(null)
            .withRejectRequestNotification(null)
            .withDeleteFriendNotification(null)
            .withLogSetting(new io.gs2.friend.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.UpdateNamespaceRequest;
using Gs2.Gs2Friend.Result.UpdateNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.UpdateNamespaceResult> asyncResult = null;
yield return client.UpdateNamespace(
    new Gs2.Gs2Friend.Request.UpdateNamespaceRequest()
        .WithNamespaceName("namespace1")
        .WithDescription("description1")
        .WithFollowScript(null)
        .WithUnfollowScript(null)
        .WithSendRequestScript(null)
        .WithCancelRequestScript(null)
        .WithAcceptRequestScript(null)
        .WithRejectRequestScript(null)
        .WithDeleteFriendScript(null)
        .WithUpdateProfileScript(null)
        .WithFollowNotification(null)
        .WithReceiveRequestNotification(null)
        .WithCancelRequestNotification(null)
        .WithAcceptRequestNotification(null)
        .WithRejectRequestNotification(null)
        .WithDeleteFriendNotification(null)
        .WithLogSetting(new Gs2.Gs2Friend.Model.LogSetting()
            .WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1")),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.updateNamespace(
        new Gs2Friend.UpdateNamespaceRequest()
            .withNamespaceName("namespace1")
            .withDescription("description1")
            .withFollowScript(null)
            .withUnfollowScript(null)
            .withSendRequestScript(null)
            .withCancelRequestScript(null)
            .withAcceptRequestScript(null)
            .withRejectRequestScript(null)
            .withDeleteFriendScript(null)
            .withUpdateProfileScript(null)
            .withFollowNotification(null)
            .withReceiveRequestNotification(null)
            .withCancelRequestNotification(null)
            .withAcceptRequestNotification(null)
            .withRejectRequestNotification(null)
            .withDeleteFriendNotification(null)
            .withLogSetting(new Gs2Friend.model.LogSetting()
                .withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1"))
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.update_namespace(
        friend.UpdateNamespaceRequest()
            .with_namespace_name(self.hash1)
            .with_description('description1')
            .with_follow_script(None)
            .with_unfollow_script(None)
            .with_send_request_script(None)
            .with_cancel_request_script(None)
            .with_accept_request_script(None)
            .with_reject_request_script(None)
            .with_delete_friend_script(None)
            .with_update_profile_script(None)
            .with_follow_notification(None)
            .with_receive_request_notification(None)
            .with_cancel_request_notification(None)
            .with_accept_request_notification(None)
            .with_reject_request_notification(None)
            .with_delete_friend_notification(None)
            .with_log_setting(
                friend.LogSetting()
                    .with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1'))
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.update_namespace({
    namespaceName="namespace1",
    description="description1",
    followScript=nil,
    unfollowScript=nil,
    sendRequestScript=nil,
    cancelRequestScript=nil,
    acceptRequestScript=nil,
    rejectRequestScript=nil,
    deleteFriendScript=nil,
    updateProfileScript=nil,
    followNotification=nil,
    receiveRequestNotification=nil,
    cancelRequestNotification=nil,
    acceptRequestNotification=nil,
    rejectRequestNotification=nil,
    deleteFriendNotification=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1",
    },
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.update_namespace_async({
    namespaceName="namespace1",
    description="description1",
    followScript=nil,
    unfollowScript=nil,
    sendRequestScript=nil,
    cancelRequestScript=nil,
    acceptRequestScript=nil,
    rejectRequestScript=nil,
    deleteFriendScript=nil,
    updateProfileScript=nil,
    followNotification=nil,
    receiveRequestNotification=nil,
    cancelRequestNotification=nil,
    acceptRequestNotification=nil,
    rejectRequestNotification=nil,
    deleteFriendNotification=nil,
    logSetting={
        loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace1",
    },
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteNamespace

Delete namespace

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name

Result

	Type	Description
item	Namespace	Deleted namespace

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DeleteNamespace(
    &friend.DeleteNamespaceRequest {
        NamespaceName: pointy.String("namespace1"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DeleteNamespaceRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteNamespace(
        (new DeleteNamespaceRequest())
            ->withNamespaceName(self::namespace1)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DeleteNamespaceRequest;
import io.gs2.friend.result.DeleteNamespaceResult;

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

try {
    DeleteNamespaceResult result = client.deleteNamespace(
        new DeleteNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    Namespace item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DeleteNamespaceRequest;
using Gs2.Gs2Friend.Result.DeleteNamespaceResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DeleteNamespaceResult> asyncResult = null;
yield return client.DeleteNamespace(
    new Gs2.Gs2Friend.Request.DeleteNamespaceRequest()
        .WithNamespaceName("namespace1"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.deleteNamespace(
        new Gs2Friend.DeleteNamespaceRequest()
            .withNamespaceName("namespace1")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.delete_namespace(
        friend.DeleteNamespaceRequest()
            .with_namespace_name(self.hash1)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.delete_namespace({
    namespaceName="namespace1",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.delete_namespace_async({
    namespaceName="namespace1",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

dumpUserDataByUserId

Get dump data of the data associated with the specified user ID

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DumpUserDataByUserId(
    &friend.DumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DumpUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->dumpUserDataByUserId(
        (new DumpUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DumpUserDataByUserIdRequest;
import io.gs2.friend.result.DumpUserDataByUserIdResult;

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

try {
    DumpUserDataByUserIdResult result = client.dumpUserDataByUserId(
        new DumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DumpUserDataByUserIdRequest;
using Gs2.Gs2Friend.Result.DumpUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DumpUserDataByUserIdResult> asyncResult = null;
yield return client.DumpUserDataByUserId(
    new Gs2.Gs2Friend.Request.DumpUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.dumpUserDataByUserId(
        new Gs2Friend.DumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.dump_user_data_by_user_id(
        friend.DumpUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.dump_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('friend')

api_result_handler = client.dump_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

checkDumpUserDataByUserId

Check if the dump of the data associated with the specified user ID is complete

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description
url	string	URL of output data

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
    &friend.CheckDumpUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
url := result.Url

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\CheckDumpUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkDumpUserDataByUserId(
        (new CheckDumpUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $url = $result->getUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.friend.result.CheckDumpUserDataByUserIdResult;

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

try {
    CheckDumpUserDataByUserIdResult result = client.checkDumpUserDataByUserId(
        new CheckDumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    String url = result.getUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.CheckDumpUserDataByUserIdRequest;
using Gs2.Gs2Friend.Result.CheckDumpUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.CheckDumpUserDataByUserIdResult> asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
    new Gs2.Gs2Friend.Request.CheckDumpUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var url = result.Url;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.checkDumpUserDataByUserId(
        new Gs2Friend.CheckDumpUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const url = result.getUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.check_dump_user_data_by_user_id(
        friend.CheckDumpUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    url = result.url
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.check_dump_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
url = result.url;

client = gs2('friend')

api_result_handler = client.check_dump_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
url = result.url;

cleanUserDataByUserId

Get clean data of the data associated with the specified user ID

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.CleanUserDataByUserId(
    &friend.CleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\CleanUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->cleanUserDataByUserId(
        (new CleanUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.CleanUserDataByUserIdRequest;
import io.gs2.friend.result.CleanUserDataByUserIdResult;

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

try {
    CleanUserDataByUserIdResult result = client.cleanUserDataByUserId(
        new CleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.CleanUserDataByUserIdRequest;
using Gs2.Gs2Friend.Result.CleanUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.CleanUserDataByUserIdResult> asyncResult = null;
yield return client.CleanUserDataByUserId(
    new Gs2.Gs2Friend.Request.CleanUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.cleanUserDataByUserId(
        new Gs2Friend.CleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.clean_user_data_by_user_id(
        friend.CleanUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.clean_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('friend')

api_result_handler = client.clean_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

checkCleanUserDataByUserId

Check if the clean of the data associated with the specified user ID is complete

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
    &friend.CheckCleanUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\CheckCleanUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkCleanUserDataByUserId(
        (new CheckCleanUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.friend.result.CheckCleanUserDataByUserIdResult;

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

try {
    CheckCleanUserDataByUserIdResult result = client.checkCleanUserDataByUserId(
        new CheckCleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.CheckCleanUserDataByUserIdRequest;
using Gs2.Gs2Friend.Result.CheckCleanUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.CheckCleanUserDataByUserIdResult> asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
    new Gs2.Gs2Friend.Request.CheckCleanUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.checkCleanUserDataByUserId(
        new Gs2Friend.CheckCleanUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.check_clean_user_data_by_user_id(
        friend.CheckCleanUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.check_clean_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('friend')

api_result_handler = client.check_clean_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

prepareImportUserDataByUserId

Start importing data associated with the specified user ID

Request

	Type	Condition	Require	Default	Limitation	Description
userId	string		✓		~ 128 chars	User Id
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description
uploadToken	string	Token used to reflect results after upload
uploadUrl	string	URL used to upload user data

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
    &friend.PrepareImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\PrepareImportUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->prepareImportUserDataByUserId(
        (new PrepareImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $uploadToken = $result->getUploadToken();
    $uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.friend.result.PrepareImportUserDataByUserIdResult;

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

try {
    PrepareImportUserDataByUserIdResult result = client.prepareImportUserDataByUserId(
        new PrepareImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    String uploadToken = result.getUploadToken();
    String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.PrepareImportUserDataByUserIdRequest;
using Gs2.Gs2Friend.Result.PrepareImportUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.PrepareImportUserDataByUserIdResult> asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
    new Gs2.Gs2Friend.Request.PrepareImportUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var uploadUrl = result.UploadUrl;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.prepareImportUserDataByUserId(
        new Gs2Friend.PrepareImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const uploadToken = result.getUploadToken();
    const uploadUrl = result.getUploadUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.prepare_import_user_data_by_user_id(
        friend.PrepareImportUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    upload_token = result.upload_token
    upload_url = result.upload_url
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.prepare_import_user_data_by_user_id({
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;

client = gs2('friend')

api_result_handler = client.prepare_import_user_data_by_user_id_async({
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;

importUserDataByUserId

Start importing data associated with the specified user ID

Request

	Type	Require	Limitation	Description
userId	string	✓	~ 128 chars	User Id
uploadToken	string	✓	~ 1024 chars	Token received in preparation for upload
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.ImportUserDataByUserId(
    &friend.ImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\ImportUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->importUserDataByUserId(
        (new ImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withUploadToken("upload-0001")
            ->withTimeOffsetToken(null)
    );
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.ImportUserDataByUserIdRequest;
import io.gs2.friend.result.ImportUserDataByUserIdResult;

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

try {
    ImportUserDataByUserIdResult result = client.importUserDataByUserId(
        new ImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.ImportUserDataByUserIdRequest;
using Gs2.Gs2Friend.Result.ImportUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.ImportUserDataByUserIdResult> asyncResult = null;
yield return client.ImportUserDataByUserId(
    new Gs2.Gs2Friend.Request.ImportUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithUploadToken("upload-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.importUserDataByUserId(
        new Gs2Friend.ImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.import_user_data_by_user_id(
        friend.ImportUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_upload_token('upload-0001')
            .with_time_offset_token(None)
    )
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.import_user_data_by_user_id({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

client = gs2('friend')

api_result_handler = client.import_user_data_by_user_id_async({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result

checkImportUserDataByUserId

Check if the import of the data associated with the specified user ID is complete

Request

	Type	Require	Limitation	Description
userId	string	✓	~ 128 chars	User Id
uploadToken	string	✓	~ 1024 chars	Token received in preparation for upload
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
url	string	URL of log data

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
    &friend.CheckImportUserDataByUserIdRequest {
        UserId: pointy.String("user-0001"),
        UploadToken: pointy.String("upload-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
url := result.Url

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\CheckImportUserDataByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->checkImportUserDataByUserId(
        (new CheckImportUserDataByUserIdRequest())
            ->withUserId("user-0001")
            ->withUploadToken("upload-0001")
            ->withTimeOffsetToken(null)
    );
    $url = $result->getUrl();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.CheckImportUserDataByUserIdRequest;
import io.gs2.friend.result.CheckImportUserDataByUserIdResult;

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

try {
    CheckImportUserDataByUserIdResult result = client.checkImportUserDataByUserId(
        new CheckImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
    String url = result.getUrl();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.CheckImportUserDataByUserIdRequest;
using Gs2.Gs2Friend.Result.CheckImportUserDataByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.CheckImportUserDataByUserIdResult> asyncResult = null;
yield return client.CheckImportUserDataByUserId(
    new Gs2.Gs2Friend.Request.CheckImportUserDataByUserIdRequest()
        .WithUserId("user-0001")
        .WithUploadToken("upload-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var url = result.Url;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.checkImportUserDataByUserId(
        new Gs2Friend.CheckImportUserDataByUserIdRequest()
            .withUserId("user-0001")
            .withUploadToken("upload-0001")
            .withTimeOffsetToken(null)
    );
    const url = result.getUrl();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.check_import_user_data_by_user_id(
        friend.CheckImportUserDataByUserIdRequest()
            .with_user_id('user-0001')
            .with_upload_token('upload-0001')
            .with_time_offset_token(None)
    )
    url = result.url
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.check_import_user_data_by_user_id({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
url = result.url;

client = gs2('friend')

api_result_handler = client.check_import_user_data_by_user_id_async({
    userId="user-0001",
    uploadToken="upload-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
url = result.url;

getProfile

Get Profile

Request

	Type	Condition	Require	Default	Limitation	Description
namespaceName	string		✓		~ 128 chars	Namespace name
accessToken	string		✓		~ 128 chars	User Id

Result

	Type	Description
item	Profile	Profile

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetProfile(
    &friend.GetProfileRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetProfileRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getProfile(
        (new GetProfileRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetProfileRequest;
import io.gs2.friend.result.GetProfileResult;

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

try {
    GetProfileResult result = client.getProfile(
        new GetProfileRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
    );
    Profile item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetProfileRequest;
using Gs2.Gs2Friend.Result.GetProfileResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetProfileResult> asyncResult = null;
yield return client.GetProfile(
    new Gs2.Gs2Friend.Request.GetProfileRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getProfile(
        new Gs2Friend.GetProfileRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_profile(
        friend.GetProfileRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_profile({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_profile_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getProfileByUserId

Get profile by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	Profile	Profile

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetProfileByUserId(
    &friend.GetProfileByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetProfileByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getProfileByUserId(
        (new GetProfileByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetProfileByUserIdRequest;
import io.gs2.friend.result.GetProfileByUserIdResult;

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

try {
    GetProfileByUserIdResult result = client.getProfileByUserId(
        new GetProfileByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    Profile item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetProfileByUserIdRequest;
using Gs2.Gs2Friend.Result.GetProfileByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetProfileByUserIdResult> asyncResult = null;
yield return client.GetProfileByUserId(
    new Gs2.Gs2Friend.Request.GetProfileByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getProfileByUserId(
        new Gs2Friend.GetProfileByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_profile_by_user_id(
        friend.GetProfileByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_profile_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_profile_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

updateProfile

Update Profile

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
publicProfile	string		~ 1024 chars	Public profile
followerProfile	string		~ 1024 chars	Profile for followers
friendProfile	string		~ 1024 chars	Profile for friends

Result

	Type	Description
item	Profile	Updated Profile

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.UpdateProfile(
    &friend.UpdateProfileRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        PublicProfile: pointy.String("public"),
        FollowerProfile: pointy.String("follower"),
        FriendProfile: pointy.String("friend"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\UpdateProfileRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateProfile(
        (new UpdateProfileRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withPublicProfile("public")
            ->withFollowerProfile("follower")
            ->withFriendProfile("friend")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.UpdateProfileRequest;
import io.gs2.friend.result.UpdateProfileResult;

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

try {
    UpdateProfileResult result = client.updateProfile(
        new UpdateProfileRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withPublicProfile("public")
            .withFollowerProfile("follower")
            .withFriendProfile("friend")
    );
    Profile item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.UpdateProfileRequest;
using Gs2.Gs2Friend.Result.UpdateProfileResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.UpdateProfileResult> asyncResult = null;
yield return client.UpdateProfile(
    new Gs2.Gs2Friend.Request.UpdateProfileRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithPublicProfile("public")
        .WithFollowerProfile("follower")
        .WithFriendProfile("friend"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.updateProfile(
        new Gs2Friend.UpdateProfileRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withPublicProfile("public")
            .withFollowerProfile("follower")
            .withFriendProfile("friend")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.update_profile(
        friend.UpdateProfileRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_public_profile('public')
            .with_follower_profile('follower')
            .with_friend_profile('friend')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.update_profile({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    publicProfile="public",
    followerProfile="follower",
    friendProfile="friend",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.update_profile_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    publicProfile="public",
    followerProfile="follower",
    friendProfile="friend",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

updateProfileByUserId

Update profile with user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
publicProfile	string		~ 1024 chars	Public profile
followerProfile	string		~ 1024 chars	Profile for followers
friendProfile	string		~ 1024 chars	Profile for friends
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	Profile	Updated Profile

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.UpdateProfileByUserId(
    &friend.UpdateProfileByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        PublicProfile: pointy.String("public2"),
        FollowerProfile: pointy.String("follower2"),
        FriendProfile: pointy.String("friend2"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\UpdateProfileByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateProfileByUserId(
        (new UpdateProfileByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withPublicProfile("public2")
            ->withFollowerProfile("follower2")
            ->withFriendProfile("friend2")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.UpdateProfileByUserIdRequest;
import io.gs2.friend.result.UpdateProfileByUserIdResult;

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

try {
    UpdateProfileByUserIdResult result = client.updateProfileByUserId(
        new UpdateProfileByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withPublicProfile("public2")
            .withFollowerProfile("follower2")
            .withFriendProfile("friend2")
            .withTimeOffsetToken(null)
    );
    Profile item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.UpdateProfileByUserIdRequest;
using Gs2.Gs2Friend.Result.UpdateProfileByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.UpdateProfileByUserIdResult> asyncResult = null;
yield return client.UpdateProfileByUserId(
    new Gs2.Gs2Friend.Request.UpdateProfileByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithPublicProfile("public2")
        .WithFollowerProfile("follower2")
        .WithFriendProfile("friend2")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.updateProfileByUserId(
        new Gs2Friend.UpdateProfileByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withPublicProfile("public2")
            .withFollowerProfile("follower2")
            .withFriendProfile("friend2")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.update_profile_by_user_id(
        friend.UpdateProfileByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_public_profile('public2')
            .with_follower_profile('follower2')
            .with_friend_profile('friend2')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.update_profile_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    publicProfile="public2",
    followerProfile="follower2",
    friendProfile="friend2",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.update_profile_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    publicProfile="public2",
    followerProfile="follower2",
    friendProfile="friend2",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteProfileByUserId

Delete profile

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	Profile	Deleted Profile

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DeleteProfileByUserId(
    &friend.DeleteProfileByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DeleteProfileByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteProfileByUserId(
        (new DeleteProfileByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DeleteProfileByUserIdRequest;
import io.gs2.friend.result.DeleteProfileByUserIdResult;

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

try {
    DeleteProfileByUserIdResult result = client.deleteProfileByUserId(
        new DeleteProfileByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    Profile item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DeleteProfileByUserIdRequest;
using Gs2.Gs2Friend.Result.DeleteProfileByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DeleteProfileByUserIdResult> asyncResult = null;
yield return client.DeleteProfileByUserId(
    new Gs2.Gs2Friend.Request.DeleteProfileByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.deleteProfileByUserId(
        new Gs2Friend.DeleteProfileByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.delete_profile_by_user_id(
        friend.DeleteProfileByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.delete_profile_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.delete_profile_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

updateProfileByStampSheet

Update profile as an acquisition action

Request

	Type	Condition	Require	Default	Limitation	Description
stampSheet	string		✓		~ 5242880 chars	Transaction
keyId	string		✓		~ 1024 chars	encryption key GRN

Result

	Type	Description
item	Profile	Updated Profile

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.UpdateProfileByStampSheet(
    &friend.UpdateProfileByStampSheetRequest {
        StampSheet: pointy.String("stampSheet"),
        KeyId: pointy.String("key-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\UpdateProfileByStampSheetRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->updateProfileByStampSheet(
        (new UpdateProfileByStampSheetRequest())
            ->withStampSheet(self::stampSheet)
            ->withKeyId(self::key-0001)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.UpdateProfileByStampSheetRequest;
import io.gs2.friend.result.UpdateProfileByStampSheetResult;

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

try {
    UpdateProfileByStampSheetResult result = client.updateProfileByStampSheet(
        new UpdateProfileByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    Profile item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.UpdateProfileByStampSheetRequest;
using Gs2.Gs2Friend.Result.UpdateProfileByStampSheetResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.UpdateProfileByStampSheetResult> asyncResult = null;
yield return client.UpdateProfileByStampSheet(
    new Gs2.Gs2Friend.Request.UpdateProfileByStampSheetRequest()
        .WithStampSheet("stampSheet")
        .WithKeyId("key-0001"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.updateProfileByStampSheet(
        new Gs2Friend.UpdateProfileByStampSheetRequest()
            .withStampSheet("stampSheet")
            .withKeyId("key-0001")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.update_profile_by_stamp_sheet(
        friend.UpdateProfileByStampSheetRequest()
            .with_stamp_sheet(self.stamp_sheet)
            .with_key_id(self.key1.key_id)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.update_profile_by_stamp_sheet({
    stampSheet="stampSheet",
    keyId="key-0001",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.update_profile_by_stamp_sheet_async({
    stampSheet="stampSheet",
    keyId="key-0001",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

describeFriends

Get list of friends

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
withProfile	bool	✓	false		Get a profile together
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	List<FriendUser>	List of Friend
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeFriends(
    &friend.DescribeFriendsRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        WithProfile: pointy.Bool(true),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeFriendsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeFriends(
        (new DescribeFriendsRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withWithProfile(True)
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeFriendsRequest;
import io.gs2.friend.result.DescribeFriendsResult;

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

try {
    DescribeFriendsResult result = client.describeFriends(
        new DescribeFriendsRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withWithProfile(true)
            .withPageToken(null)
            .withLimit(null)
    );
    List<FriendUser> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeFriendsRequest;
using Gs2.Gs2Friend.Result.DescribeFriendsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeFriendsResult> asyncResult = null;
yield return client.DescribeFriends(
    new Gs2.Gs2Friend.Request.DescribeFriendsRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithWithProfile(true)
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeFriends(
        new Gs2Friend.DescribeFriendsRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withWithProfile(true)
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_friends(
        friend.DescribeFriendsRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_with_profile(True)
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_friends({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    withProfile=true,
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_friends_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    withProfile=true,
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

describeFriendsByUserId

Get list of friends by user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
withProfile	bool	✓	false		Get a profile together
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<FriendUser>	List of Friend
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeFriendsByUserId(
    &friend.DescribeFriendsByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        WithProfile: pointy.Bool(true),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeFriendsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeFriendsByUserId(
        (new DescribeFriendsByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withWithProfile(True)
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeFriendsByUserIdRequest;
import io.gs2.friend.result.DescribeFriendsByUserIdResult;

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

try {
    DescribeFriendsByUserIdResult result = client.describeFriendsByUserId(
        new DescribeFriendsByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withWithProfile(true)
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<FriendUser> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeFriendsByUserIdRequest;
using Gs2.Gs2Friend.Result.DescribeFriendsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeFriendsByUserIdResult> asyncResult = null;
yield return client.DescribeFriendsByUserId(
    new Gs2.Gs2Friend.Request.DescribeFriendsByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithWithProfile(true)
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeFriendsByUserId(
        new Gs2Friend.DescribeFriendsByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withWithProfile(true)
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_friends_by_user_id(
        friend.DescribeFriendsByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_with_profile(True)
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_friends_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    withProfile=true,
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_friends_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    withProfile=true,
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

describeBlackList

Get Blacklist

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	List<string>	Blacklisted user ID list
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeBlackList(
    &friend.DescribeBlackListRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeBlackListRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBlackList(
        (new DescribeBlackListRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeBlackListRequest;
import io.gs2.friend.result.DescribeBlackListResult;

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

try {
    DescribeBlackListResult result = client.describeBlackList(
        new DescribeBlackListRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<String> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeBlackListRequest;
using Gs2.Gs2Friend.Result.DescribeBlackListResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeBlackListResult> asyncResult = null;
yield return client.DescribeBlackList(
    new Gs2.Gs2Friend.Request.DescribeBlackListRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeBlackList(
        new Gs2Friend.DescribeBlackListRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_black_list(
        friend.DescribeBlackListRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_black_list({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_black_list_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

describeBlackListByUserId

Get blacklist by specifying user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<string>	Blacklisted user ID list
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeBlackListByUserId(
    &friend.DescribeBlackListByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeBlackListByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeBlackListByUserId(
        (new DescribeBlackListByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeBlackListByUserIdRequest;
import io.gs2.friend.result.DescribeBlackListByUserIdResult;

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

try {
    DescribeBlackListByUserIdResult result = client.describeBlackListByUserId(
        new DescribeBlackListByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<String> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeBlackListByUserIdRequest;
using Gs2.Gs2Friend.Result.DescribeBlackListByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeBlackListByUserIdResult> asyncResult = null;
yield return client.DescribeBlackListByUserId(
    new Gs2.Gs2Friend.Request.DescribeBlackListByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeBlackListByUserId(
        new Gs2Friend.DescribeBlackListByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_black_list_by_user_id(
        friend.DescribeBlackListByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_black_list_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_black_list_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

registerBlackList

Add to blacklist

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id

Result

	Type	Description
item	BlackList	blacklist

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.RegisterBlackList(
    &friend.RegisterBlackListRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        TargetUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\RegisterBlackListRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->registerBlackList(
        (new RegisterBlackListRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withTargetUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.RegisterBlackListRequest;
import io.gs2.friend.result.RegisterBlackListResult;

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

try {
    RegisterBlackListResult result = client.registerBlackList(
        new RegisterBlackListRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    BlackList item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.RegisterBlackListRequest;
using Gs2.Gs2Friend.Result.RegisterBlackListResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.RegisterBlackListResult> asyncResult = null;
yield return client.RegisterBlackList(
    new Gs2.Gs2Friend.Request.RegisterBlackListRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithTargetUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.registerBlackList(
        new Gs2Friend.RegisterBlackListRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.register_black_list(
        friend.RegisterBlackListRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_target_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.register_black_list({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.register_black_list_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

registerBlackListByUserId

Add to blacklist by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	BlackList	blacklist

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.RegisterBlackListByUserId(
    &friend.RegisterBlackListByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TargetUserId: pointy.String("user-0002"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\RegisterBlackListByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->registerBlackListByUserId(
        (new RegisterBlackListByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTargetUserId("user-0002")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.RegisterBlackListByUserIdRequest;
import io.gs2.friend.result.RegisterBlackListByUserIdResult;

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

try {
    RegisterBlackListByUserIdResult result = client.registerBlackListByUserId(
        new RegisterBlackListByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    BlackList item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.RegisterBlackListByUserIdRequest;
using Gs2.Gs2Friend.Result.RegisterBlackListByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.RegisterBlackListByUserIdResult> asyncResult = null;
yield return client.RegisterBlackListByUserId(
    new Gs2.Gs2Friend.Request.RegisterBlackListByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTargetUserId("user-0002")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.registerBlackListByUserId(
        new Gs2Friend.RegisterBlackListByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.register_black_list_by_user_id(
        friend.RegisterBlackListByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_target_user_id('user-0002')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.register_black_list_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId="user-0002",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.register_black_list_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId="user-0002",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

unregisterBlackList

Remove a user from blacklist

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id

Result

	Type	Description
item	BlackList	Blacklist

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.UnregisterBlackList(
    &friend.UnregisterBlackListRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        TargetUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\UnregisterBlackListRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->unregisterBlackList(
        (new UnregisterBlackListRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withTargetUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.UnregisterBlackListRequest;
import io.gs2.friend.result.UnregisterBlackListResult;

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

try {
    UnregisterBlackListResult result = client.unregisterBlackList(
        new UnregisterBlackListRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    BlackList item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.UnregisterBlackListRequest;
using Gs2.Gs2Friend.Result.UnregisterBlackListResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.UnregisterBlackListResult> asyncResult = null;
yield return client.UnregisterBlackList(
    new Gs2.Gs2Friend.Request.UnregisterBlackListRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithTargetUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.unregisterBlackList(
        new Gs2Friend.UnregisterBlackListRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.unregister_black_list(
        friend.UnregisterBlackListRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_target_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.unregister_black_list({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.unregister_black_list_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

unregisterBlackListByUserId

Remove a user from the blacklist by specifying the user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	BlackList	Blacklist

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.UnregisterBlackListByUserId(
    &friend.UnregisterBlackListByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TargetUserId: pointy.String("user-0002"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\UnregisterBlackListByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->unregisterBlackListByUserId(
        (new UnregisterBlackListByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTargetUserId("user-0002")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.UnregisterBlackListByUserIdRequest;
import io.gs2.friend.result.UnregisterBlackListByUserIdResult;

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

try {
    UnregisterBlackListByUserIdResult result = client.unregisterBlackListByUserId(
        new UnregisterBlackListByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    BlackList item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.UnregisterBlackListByUserIdRequest;
using Gs2.Gs2Friend.Result.UnregisterBlackListByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.UnregisterBlackListByUserIdResult> asyncResult = null;
yield return client.UnregisterBlackListByUserId(
    new Gs2.Gs2Friend.Request.UnregisterBlackListByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTargetUserId("user-0002")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.unregisterBlackListByUserId(
        new Gs2Friend.UnregisterBlackListByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.unregister_black_list_by_user_id(
        friend.UnregisterBlackListByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_target_user_id('user-0002')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.unregister_black_list_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId="user-0002",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.unregister_black_list_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId="user-0002",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

describeFollows

Get list of followings

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
withProfile	bool	✓	false		Get a profile together
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	List<FollowUser>	List of Following user
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeFollows(
    &friend.DescribeFollowsRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        WithProfile: pointy.Bool(true),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeFollowsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeFollows(
        (new DescribeFollowsRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withWithProfile(True)
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeFollowsRequest;
import io.gs2.friend.result.DescribeFollowsResult;

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

try {
    DescribeFollowsResult result = client.describeFollows(
        new DescribeFollowsRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withWithProfile(true)
            .withPageToken(null)
            .withLimit(null)
    );
    List<FollowUser> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeFollowsRequest;
using Gs2.Gs2Friend.Result.DescribeFollowsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeFollowsResult> asyncResult = null;
yield return client.DescribeFollows(
    new Gs2.Gs2Friend.Request.DescribeFollowsRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithWithProfile(true)
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeFollows(
        new Gs2Friend.DescribeFollowsRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withWithProfile(true)
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_follows(
        friend.DescribeFollowsRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_with_profile(True)
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_follows({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    withProfile=true,
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_follows_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    withProfile=true,
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

describeFollowsByUserId

Get list of followers by user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
withProfile	bool	✓	false		Get a profile together
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<FollowUser>	List of Following user
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeFollowsByUserId(
    &friend.DescribeFollowsByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        WithProfile: pointy.Bool(true),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeFollowsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeFollowsByUserId(
        (new DescribeFollowsByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withWithProfile(True)
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeFollowsByUserIdRequest;
import io.gs2.friend.result.DescribeFollowsByUserIdResult;

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

try {
    DescribeFollowsByUserIdResult result = client.describeFollowsByUserId(
        new DescribeFollowsByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withWithProfile(true)
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<FollowUser> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeFollowsByUserIdRequest;
using Gs2.Gs2Friend.Result.DescribeFollowsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeFollowsByUserIdResult> asyncResult = null;
yield return client.DescribeFollowsByUserId(
    new Gs2.Gs2Friend.Request.DescribeFollowsByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithWithProfile(true)
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeFollowsByUserId(
        new Gs2Friend.DescribeFollowsByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withWithProfile(true)
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_follows_by_user_id(
        friend.DescribeFollowsByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_with_profile(True)
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_follows_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    withProfile=true,
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_follows_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    withProfile=true,
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

getFollow

Get a Following user

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
targetUserId	string	✓		~ 128 chars	User Id
withProfile	bool	✓	false		Get a profile together

Result

	Type	Description
item	FollowUser	Following user

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetFollow(
    &friend.GetFollowRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        TargetUserId: pointy.String("user-0002"),
        WithProfile: pointy.Bool(true),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetFollowRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getFollow(
        (new GetFollowRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withTargetUserId("user-0002")
            ->withWithProfile(True)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetFollowRequest;
import io.gs2.friend.result.GetFollowResult;

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

try {
    GetFollowResult result = client.getFollow(
        new GetFollowRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
            .withWithProfile(true)
    );
    FollowUser item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetFollowRequest;
using Gs2.Gs2Friend.Result.GetFollowResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetFollowResult> asyncResult = null;
yield return client.GetFollow(
    new Gs2.Gs2Friend.Request.GetFollowRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithTargetUserId("user-0002")
        .WithWithProfile(true),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getFollow(
        new Gs2Friend.GetFollowRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
            .withWithProfile(true)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_follow(
        friend.GetFollowRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_target_user_id('user-0002')
            .with_with_profile(True)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_follow({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
    withProfile=true,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_follow_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
    withProfile=true,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getFollowByUserId

Get a Following user by user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
targetUserId	string	✓		~ 128 chars	User Id
withProfile	bool	✓	false		Get a profile together
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
item	FollowUser	Following user

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetFollowByUserId(
    &friend.GetFollowByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TargetUserId: pointy.String("user-0002"),
        WithProfile: pointy.Bool(true),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetFollowByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getFollowByUserId(
        (new GetFollowByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTargetUserId("user-0002")
            ->withWithProfile(True)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetFollowByUserIdRequest;
import io.gs2.friend.result.GetFollowByUserIdResult;

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

try {
    GetFollowByUserIdResult result = client.getFollowByUserId(
        new GetFollowByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId("user-0002")
            .withWithProfile(true)
            .withTimeOffsetToken(null)
    );
    FollowUser item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetFollowByUserIdRequest;
using Gs2.Gs2Friend.Result.GetFollowByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetFollowByUserIdResult> asyncResult = null;
yield return client.GetFollowByUserId(
    new Gs2.Gs2Friend.Request.GetFollowByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTargetUserId("user-0002")
        .WithWithProfile(true)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getFollowByUserId(
        new Gs2Friend.GetFollowByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId("user-0002")
            .withWithProfile(true)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_follow_by_user_id(
        friend.GetFollowByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_target_user_id('user-0002')
            .with_with_profile(True)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_follow_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId="user-0002",
    withProfile=true,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_follow_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId="user-0002",
    withProfile=true,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

follow

Follow to other player

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User ID of the person want to follow

Result

	Type	Description
item	FollowUser	Followed user

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.Follow(
    &friend.FollowRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        TargetUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\FollowRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->follow(
        (new FollowRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withTargetUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.FollowRequest;
import io.gs2.friend.result.FollowResult;

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

try {
    FollowResult result = client.follow(
        new FollowRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    FollowUser item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.FollowRequest;
using Gs2.Gs2Friend.Result.FollowResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.FollowResult> asyncResult = null;
yield return client.Follow(
    new Gs2.Gs2Friend.Request.FollowRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithTargetUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.follow(
        new Gs2Friend.FollowRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.follow(
        friend.FollowRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_target_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.follow({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.follow_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

followByUserId

Follow to other player by user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User ID of the person want to follow
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	FollowUser	Followed user

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.FollowByUserId(
    &friend.FollowByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TargetUserId: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\FollowByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->followByUserId(
        (new FollowByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTargetUserId(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.FollowByUserIdRequest;
import io.gs2.friend.result.FollowByUserIdResult;

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

try {
    FollowByUserIdResult result = client.followByUserId(
        new FollowByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId(null)
            .withTimeOffsetToken(null)
    );
    FollowUser item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.FollowByUserIdRequest;
using Gs2.Gs2Friend.Result.FollowByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.FollowByUserIdResult> asyncResult = null;
yield return client.FollowByUserId(
    new Gs2.Gs2Friend.Request.FollowByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTargetUserId(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.followByUserId(
        new Gs2Friend.FollowByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.follow_by_user_id(
        friend.FollowByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_target_user_id(None)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.follow_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.follow_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

unfollow

Unfollow to other player

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id

Result

	Type	Description
item	FollowUser	Unfollowed user

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.Unfollow(
    &friend.UnfollowRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        TargetUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\UnfollowRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->unfollow(
        (new UnfollowRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withTargetUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.UnfollowRequest;
import io.gs2.friend.result.UnfollowResult;

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

try {
    UnfollowResult result = client.unfollow(
        new UnfollowRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    FollowUser item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.UnfollowRequest;
using Gs2.Gs2Friend.Result.UnfollowResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.UnfollowResult> asyncResult = null;
yield return client.Unfollow(
    new Gs2.Gs2Friend.Request.UnfollowRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithTargetUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.unfollow(
        new Gs2Friend.UnfollowRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.unfollow(
        friend.UnfollowRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_target_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.unfollow({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.unfollow_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

unfollowByUserId

Unfollow to other player by user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	FollowUser	Unfollowed user

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.UnfollowByUserId(
    &friend.UnfollowByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TargetUserId: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\UnfollowByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->unfollowByUserId(
        (new UnfollowByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTargetUserId(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.UnfollowByUserIdRequest;
import io.gs2.friend.result.UnfollowByUserIdResult;

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

try {
    UnfollowByUserIdResult result = client.unfollowByUserId(
        new UnfollowByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId(null)
            .withTimeOffsetToken(null)
    );
    FollowUser item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.UnfollowByUserIdRequest;
using Gs2.Gs2Friend.Result.UnfollowByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.UnfollowByUserIdResult> asyncResult = null;
yield return client.UnfollowByUserId(
    new Gs2.Gs2Friend.Request.UnfollowByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTargetUserId(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.unfollowByUserId(
        new Gs2Friend.UnfollowByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.unfollow_by_user_id(
        friend.UnfollowByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_target_user_id(None)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.unfollow_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.unfollow_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getFriend

Get a Friend

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
targetUserId	string	✓		~ 128 chars	User Id
withProfile	bool	✓	false		Get a profile together

Result

	Type	Description
item	FriendUser	Friend

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetFriend(
    &friend.GetFriendRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        TargetUserId: pointy.String("user-0002"),
        WithProfile: pointy.Bool(true),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetFriendRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getFriend(
        (new GetFriendRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withTargetUserId("user-0002")
            ->withWithProfile(True)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetFriendRequest;
import io.gs2.friend.result.GetFriendResult;

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

try {
    GetFriendResult result = client.getFriend(
        new GetFriendRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
            .withWithProfile(true)
    );
    FriendUser item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetFriendRequest;
using Gs2.Gs2Friend.Result.GetFriendResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetFriendResult> asyncResult = null;
yield return client.GetFriend(
    new Gs2.Gs2Friend.Request.GetFriendRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithTargetUserId("user-0002")
        .WithWithProfile(true),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getFriend(
        new Gs2Friend.GetFriendRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
            .withWithProfile(true)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_friend(
        friend.GetFriendRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_target_user_id('user-0002')
            .with_with_profile(True)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_friend({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
    withProfile=true,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_friend_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
    withProfile=true,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getFriendByUserId

Get a Friend by user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
targetUserId	string	✓		~ 128 chars	User Id
withProfile	bool	✓	false		Get a profile together
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
item	FriendUser	Friend

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetFriendByUserId(
    &friend.GetFriendByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TargetUserId: pointy.String("user-0002"),
        WithProfile: pointy.Bool(true),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetFriendByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getFriendByUserId(
        (new GetFriendByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTargetUserId("user-0002")
            ->withWithProfile(True)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetFriendByUserIdRequest;
import io.gs2.friend.result.GetFriendByUserIdResult;

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

try {
    GetFriendByUserIdResult result = client.getFriendByUserId(
        new GetFriendByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId("user-0002")
            .withWithProfile(true)
            .withTimeOffsetToken(null)
    );
    FriendUser item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetFriendByUserIdRequest;
using Gs2.Gs2Friend.Result.GetFriendByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetFriendByUserIdResult> asyncResult = null;
yield return client.GetFriendByUserId(
    new Gs2.Gs2Friend.Request.GetFriendByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTargetUserId("user-0002")
        .WithWithProfile(true)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getFriendByUserId(
        new Gs2Friend.GetFriendByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId("user-0002")
            .withWithProfile(true)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_friend_by_user_id(
        friend.GetFriendByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_target_user_id('user-0002')
            .with_with_profile(True)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_friend_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId="user-0002",
    withProfile=true,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_friend_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId="user-0002",
    withProfile=true,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteFriend

Delete Friend

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id

Result

	Type	Description
item	FriendUser	Deleted Friend

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DeleteFriend(
    &friend.DeleteFriendRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        TargetUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DeleteFriendRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteFriend(
        (new DeleteFriendRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withTargetUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DeleteFriendRequest;
import io.gs2.friend.result.DeleteFriendResult;

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

try {
    DeleteFriendResult result = client.deleteFriend(
        new DeleteFriendRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    FriendUser item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DeleteFriendRequest;
using Gs2.Gs2Friend.Result.DeleteFriendResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DeleteFriendResult> asyncResult = null;
yield return client.DeleteFriend(
    new Gs2.Gs2Friend.Request.DeleteFriendRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithTargetUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.deleteFriend(
        new Gs2Friend.DeleteFriendRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.delete_friend(
        friend.DeleteFriendRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_target_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.delete_friend({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.delete_friend_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteFriendByUserId

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	FriendUser	Deleted Friend

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DeleteFriendByUserId(
    &friend.DeleteFriendByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TargetUserId: pointy.String("user-0002"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DeleteFriendByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteFriendByUserId(
        (new DeleteFriendByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTargetUserId("user-0002")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DeleteFriendByUserIdRequest;
import io.gs2.friend.result.DeleteFriendByUserIdResult;

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

try {
    DeleteFriendByUserIdResult result = client.deleteFriendByUserId(
        new DeleteFriendByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    FriendUser item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DeleteFriendByUserIdRequest;
using Gs2.Gs2Friend.Result.DeleteFriendByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DeleteFriendByUserIdResult> asyncResult = null;
yield return client.DeleteFriendByUserId(
    new Gs2.Gs2Friend.Request.DeleteFriendByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTargetUserId("user-0002")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.deleteFriendByUserId(
        new Gs2Friend.DeleteFriendByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.delete_friend_by_user_id(
        friend.DeleteFriendByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_target_user_id('user-0002')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.delete_friend_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId="user-0002",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.delete_friend_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId="user-0002",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

describeSendRequests

Get list of friend requests you have sent

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	List<FriendRequest>	List of Friend Request
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeSendRequests(
    &friend.DescribeSendRequestsRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeSendRequestsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeSendRequests(
        (new DescribeSendRequestsRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeSendRequestsRequest;
import io.gs2.friend.result.DescribeSendRequestsResult;

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

try {
    DescribeSendRequestsResult result = client.describeSendRequests(
        new DescribeSendRequestsRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<FriendRequest> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeSendRequestsRequest;
using Gs2.Gs2Friend.Result.DescribeSendRequestsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeSendRequestsResult> asyncResult = null;
yield return client.DescribeSendRequests(
    new Gs2.Gs2Friend.Request.DescribeSendRequestsRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeSendRequests(
        new Gs2Friend.DescribeSendRequestsRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_send_requests(
        friend.DescribeSendRequestsRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_send_requests({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_send_requests_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

describeSendRequestsByUserId

Obtain list of friend requests sent by specifying a user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<FriendRequest>	List of Friend Request
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeSendRequestsByUserId(
    &friend.DescribeSendRequestsByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeSendRequestsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeSendRequestsByUserId(
        (new DescribeSendRequestsByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeSendRequestsByUserIdRequest;
import io.gs2.friend.result.DescribeSendRequestsByUserIdResult;

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

try {
    DescribeSendRequestsByUserIdResult result = client.describeSendRequestsByUserId(
        new DescribeSendRequestsByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<FriendRequest> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeSendRequestsByUserIdRequest;
using Gs2.Gs2Friend.Result.DescribeSendRequestsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeSendRequestsByUserIdResult> asyncResult = null;
yield return client.DescribeSendRequestsByUserId(
    new Gs2.Gs2Friend.Request.DescribeSendRequestsByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeSendRequestsByUserId(
        new Gs2Friend.DescribeSendRequestsByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_send_requests_by_user_id(
        friend.DescribeSendRequestsByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_send_requests_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_send_requests_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

getSendRequest

Retrieve friend requests sent

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id

Result

	Type	Description
item	FriendRequest	Friend Request

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetSendRequest(
    &friend.GetSendRequestRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        TargetUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetSendRequestRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getSendRequest(
        (new GetSendRequestRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withTargetUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetSendRequestRequest;
import io.gs2.friend.result.GetSendRequestResult;

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

try {
    GetSendRequestResult result = client.getSendRequest(
        new GetSendRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetSendRequestRequest;
using Gs2.Gs2Friend.Result.GetSendRequestResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetSendRequestResult> asyncResult = null;
yield return client.GetSendRequest(
    new Gs2.Gs2Friend.Request.GetSendRequestRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithTargetUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getSendRequest(
        new Gs2Friend.GetSendRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_send_request(
        friend.GetSendRequestRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_target_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_send_request({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_send_request_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getSendRequestByUserId

Retrieves friend requests sent by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	FriendRequest	Friend Request

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetSendRequestByUserId(
    &friend.GetSendRequestByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TargetUserId: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetSendRequestByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getSendRequestByUserId(
        (new GetSendRequestByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTargetUserId(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetSendRequestByUserIdRequest;
import io.gs2.friend.result.GetSendRequestByUserIdResult;

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

try {
    GetSendRequestByUserIdResult result = client.getSendRequestByUserId(
        new GetSendRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId(null)
            .withTimeOffsetToken(null)
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetSendRequestByUserIdRequest;
using Gs2.Gs2Friend.Result.GetSendRequestByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetSendRequestByUserIdResult> asyncResult = null;
yield return client.GetSendRequestByUserId(
    new Gs2.Gs2Friend.Request.GetSendRequestByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTargetUserId(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getSendRequestByUserId(
        new Gs2Friend.GetSendRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_send_request_by_user_id(
        friend.GetSendRequestByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_target_user_id(None)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_send_request_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_send_request_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

sendRequest

Send a friend request

If the number of “current friends” reaches 1000, you cannot send a new request. If there is one or more “unaccepted friend requests”, the oldest “unaccepted friend request” will be withdrawn and a new request will be sent.

And, if the recipient of the friend request has 1000 “unaccepted friend requests”, the oldest “unaccepted friend request” will be withdrawn and a new request will be accepted.

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User ID of the person want to be friend

Result

	Type	Description
item	FriendRequest	Friend request sent

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.SendRequest(
    &friend.SendRequestRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        TargetUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\SendRequestRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->sendRequest(
        (new SendRequestRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withTargetUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.SendRequestRequest;
import io.gs2.friend.result.SendRequestResult;

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

try {
    SendRequestResult result = client.sendRequest(
        new SendRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.SendRequestRequest;
using Gs2.Gs2Friend.Result.SendRequestResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.SendRequestResult> asyncResult = null;
yield return client.SendRequest(
    new Gs2.Gs2Friend.Request.SendRequestRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithTargetUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.sendRequest(
        new Gs2Friend.SendRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.send_request(
        friend.SendRequestRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_target_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.send_request({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.send_request_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

sendRequestByUserId

Send a friend request specifying user ID

And, if the recipient of the friend request has 1000 “unaccepted friend requests”, the oldest “unaccepted friend request” will be withdrawn and a new request will be accepted.

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User ID of the person want to be friend
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	FriendRequest	Friend request sent

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.SendRequestByUserId(
    &friend.SendRequestByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TargetUserId: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\SendRequestByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->sendRequestByUserId(
        (new SendRequestByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTargetUserId(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.SendRequestByUserIdRequest;
import io.gs2.friend.result.SendRequestByUserIdResult;

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

try {
    SendRequestByUserIdResult result = client.sendRequestByUserId(
        new SendRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId(null)
            .withTimeOffsetToken(null)
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.SendRequestByUserIdRequest;
using Gs2.Gs2Friend.Result.SendRequestByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.SendRequestByUserIdResult> asyncResult = null;
yield return client.SendRequestByUserId(
    new Gs2.Gs2Friend.Request.SendRequestByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTargetUserId(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.sendRequestByUserId(
        new Gs2Friend.SendRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.send_request_by_user_id(
        friend.SendRequestByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_target_user_id(None)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.send_request_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.send_request_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteRequest

Delete friend request

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id

Result

	Type	Description
item	FriendRequest	Deleted Friend Requests

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DeleteRequest(
    &friend.DeleteRequestRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        TargetUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DeleteRequestRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteRequest(
        (new DeleteRequestRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withTargetUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DeleteRequestRequest;
import io.gs2.friend.result.DeleteRequestResult;

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

try {
    DeleteRequestResult result = client.deleteRequest(
        new DeleteRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DeleteRequestRequest;
using Gs2.Gs2Friend.Result.DeleteRequestResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DeleteRequestResult> asyncResult = null;
yield return client.DeleteRequest(
    new Gs2.Gs2Friend.Request.DeleteRequestRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithTargetUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.deleteRequest(
        new Gs2Friend.DeleteRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withTargetUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.delete_request(
        friend.DeleteRequestRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_target_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.delete_request({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.delete_request_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    targetUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

deleteRequestByUserId

Delete friend request by specifying user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
targetUserId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	FriendRequest	Deleted Friend Requests

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DeleteRequestByUserId(
    &friend.DeleteRequestByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TargetUserId: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DeleteRequestByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->deleteRequestByUserId(
        (new DeleteRequestByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTargetUserId(null)
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DeleteRequestByUserIdRequest;
import io.gs2.friend.result.DeleteRequestByUserIdResult;

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

try {
    DeleteRequestByUserIdResult result = client.deleteRequestByUserId(
        new DeleteRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId(null)
            .withTimeOffsetToken(null)
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DeleteRequestByUserIdRequest;
using Gs2.Gs2Friend.Result.DeleteRequestByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DeleteRequestByUserIdResult> asyncResult = null;
yield return client.DeleteRequestByUserId(
    new Gs2.Gs2Friend.Request.DeleteRequestByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTargetUserId(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.deleteRequestByUserId(
        new Gs2Friend.DeleteRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTargetUserId(null)
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.delete_request_by_user_id(
        friend.DeleteRequestByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_target_user_id(None)
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.delete_request_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.delete_request_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    targetUserId=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

describeReceiveRequests

Get list of received friend requests

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
accessToken	string	✓		~ 128 chars	User Id
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired

Result

	Type	Description
items	List<FriendRequest>	List of Friend request
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeReceiveRequests(
    &friend.DescribeReceiveRequestsRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        PageToken: nil,
        Limit: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeReceiveRequestsRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeReceiveRequests(
        (new DescribeReceiveRequestsRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withPageToken(null)
            ->withLimit(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeReceiveRequestsRequest;
import io.gs2.friend.result.DescribeReceiveRequestsResult;

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

try {
    DescribeReceiveRequestsResult result = client.describeReceiveRequests(
        new DescribeReceiveRequestsRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    List<FriendRequest> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeReceiveRequestsRequest;
using Gs2.Gs2Friend.Result.DescribeReceiveRequestsResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeReceiveRequestsResult> asyncResult = null;
yield return client.DescribeReceiveRequests(
    new Gs2.Gs2Friend.Request.DescribeReceiveRequestsRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithPageToken(null)
        .WithLimit(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeReceiveRequests(
        new Gs2Friend.DescribeReceiveRequestsRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withPageToken(null)
            .withLimit(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_receive_requests(
        friend.DescribeReceiveRequestsRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_page_token(None)
            .with_limit(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_receive_requests({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_receive_requests_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    pageToken=nil,
    limit=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

describeReceiveRequestsByUserId

Obtain list of friend requests received by specifying a user ID

Request

	Type	Require	Default	Limitation	Description
namespaceName	string	✓		~ 128 chars	Namespace name
userId	string	✓		~ 128 chars	User Id
pageToken	string			~ 1024 chars	Token specifying the position from which to start acquiring data
limit	int	✓	30	1 ~ 1000	Number of data acquired
timeOffsetToken	string			~ 1024 chars	Time offset token

Result

	Type	Description
items	List<FriendRequest>	List of Friend request
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.DescribeReceiveRequestsByUserId(
    &friend.DescribeReceiveRequestsByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        PageToken: nil,
        Limit: nil,
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\DescribeReceiveRequestsByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->describeReceiveRequestsByUserId(
        (new DescribeReceiveRequestsByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withPageToken(null)
            ->withLimit(null)
            ->withTimeOffsetToken(null)
    );
    $items = $result->getItems();
    $nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.DescribeReceiveRequestsByUserIdRequest;
import io.gs2.friend.result.DescribeReceiveRequestsByUserIdResult;

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

try {
    DescribeReceiveRequestsByUserIdResult result = client.describeReceiveRequestsByUserId(
        new DescribeReceiveRequestsByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    List<FriendRequest> items = result.getItems();
    String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.DescribeReceiveRequestsByUserIdRequest;
using Gs2.Gs2Friend.Result.DescribeReceiveRequestsByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.DescribeReceiveRequestsByUserIdResult> asyncResult = null;
yield return client.DescribeReceiveRequestsByUserId(
    new Gs2.Gs2Friend.Request.DescribeReceiveRequestsByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithPageToken(null)
        .WithLimit(null)
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.describeReceiveRequestsByUserId(
        new Gs2Friend.DescribeReceiveRequestsByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withPageToken(null)
            .withLimit(null)
            .withTimeOffsetToken(null)
    );
    const items = result.getItems();
    const nextPageToken = result.getNextPageToken();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.describe_receive_requests_by_user_id(
        friend.DescribeReceiveRequestsByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_page_token(None)
            .with_limit(None)
            .with_time_offset_token(None)
    )
    items = result.items
    next_page_token = result.next_page_token
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.describe_receive_requests_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

client = gs2('friend')

api_result_handler = client.describe_receive_requests_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    pageToken=nil,
    limit=nil,
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;

getReceiveRequest

Retrieve received friend requests

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
fromUserId	string	✓	~ 128 chars	User Id

Result

	Type	Description
item	FriendRequest	Friend request

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetReceiveRequest(
    &friend.GetReceiveRequestRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        FromUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetReceiveRequestRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getReceiveRequest(
        (new GetReceiveRequestRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withFromUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetReceiveRequestRequest;
import io.gs2.friend.result.GetReceiveRequestResult;

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

try {
    GetReceiveRequestResult result = client.getReceiveRequest(
        new GetReceiveRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withFromUserId("user-0002")
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetReceiveRequestRequest;
using Gs2.Gs2Friend.Result.GetReceiveRequestResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetReceiveRequestResult> asyncResult = null;
yield return client.GetReceiveRequest(
    new Gs2.Gs2Friend.Request.GetReceiveRequestRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithFromUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getReceiveRequest(
        new Gs2Friend.GetReceiveRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withFromUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_receive_request(
        friend.GetReceiveRequestRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_from_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_receive_request({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    fromUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_receive_request_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    fromUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getReceiveRequestByUserId

Retrieve friend requests received with user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
fromUserId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	FriendRequest	Friend request

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetReceiveRequestByUserId(
    &friend.GetReceiveRequestByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        FromUserId: pointy.String("user-0002"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetReceiveRequestByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getReceiveRequestByUserId(
        (new GetReceiveRequestByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withFromUserId("user-0002")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetReceiveRequestByUserIdRequest;
import io.gs2.friend.result.GetReceiveRequestByUserIdResult;

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

try {
    GetReceiveRequestByUserIdResult result = client.getReceiveRequestByUserId(
        new GetReceiveRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withFromUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetReceiveRequestByUserIdRequest;
using Gs2.Gs2Friend.Result.GetReceiveRequestByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetReceiveRequestByUserIdResult> asyncResult = null;
yield return client.GetReceiveRequestByUserId(
    new Gs2.Gs2Friend.Request.GetReceiveRequestByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithFromUserId("user-0002")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getReceiveRequestByUserId(
        new Gs2Friend.GetReceiveRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withFromUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_receive_request_by_user_id(
        friend.GetReceiveRequestByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_from_user_id('user-0002')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_receive_request_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    fromUserId="user-0002",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_receive_request_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    fromUserId="user-0002",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

acceptRequest

Accept Friend Request

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
fromUserId	string	✓	~ 128 chars	User Id

Result

	Type	Description
item	FriendRequest	Accepted Friend Request

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.AcceptRequest(
    &friend.AcceptRequestRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        FromUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\AcceptRequestRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->acceptRequest(
        (new AcceptRequestRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withFromUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.AcceptRequestRequest;
import io.gs2.friend.result.AcceptRequestResult;

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

try {
    AcceptRequestResult result = client.acceptRequest(
        new AcceptRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withFromUserId("user-0002")
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.AcceptRequestRequest;
using Gs2.Gs2Friend.Result.AcceptRequestResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.AcceptRequestResult> asyncResult = null;
yield return client.AcceptRequest(
    new Gs2.Gs2Friend.Request.AcceptRequestRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithFromUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.acceptRequest(
        new Gs2Friend.AcceptRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withFromUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.accept_request(
        friend.AcceptRequestRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_from_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.accept_request({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    fromUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.accept_request_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    fromUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

acceptRequestByUserId

Accept friend request with user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
fromUserId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	FriendRequest	Accepted Friend Request

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.AcceptRequestByUserId(
    &friend.AcceptRequestByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        FromUserId: pointy.String("user-0002"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\AcceptRequestByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->acceptRequestByUserId(
        (new AcceptRequestByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withFromUserId("user-0002")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.AcceptRequestByUserIdRequest;
import io.gs2.friend.result.AcceptRequestByUserIdResult;

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

try {
    AcceptRequestByUserIdResult result = client.acceptRequestByUserId(
        new AcceptRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withFromUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.AcceptRequestByUserIdRequest;
using Gs2.Gs2Friend.Result.AcceptRequestByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.AcceptRequestByUserIdResult> asyncResult = null;
yield return client.AcceptRequestByUserId(
    new Gs2.Gs2Friend.Request.AcceptRequestByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithFromUserId("user-0002")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.acceptRequestByUserId(
        new Gs2Friend.AcceptRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withFromUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.accept_request_by_user_id(
        friend.AcceptRequestByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_from_user_id('user-0002')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.accept_request_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    fromUserId="user-0002",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.accept_request_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    fromUserId="user-0002",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

rejectRequest

Reject friend request

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
accessToken	string	✓	~ 128 chars	User Id
fromUserId	string	✓	~ 128 chars	User Id

Result

	Type	Description
item	FriendRequest	Rejected friend request

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.RejectRequest(
    &friend.RejectRequestRequest {
        NamespaceName: pointy.String("namespace2"),
        AccessToken: pointy.String("accessToken-0001"),
        FromUserId: pointy.String("user-0002"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\RejectRequestRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->rejectRequest(
        (new RejectRequestRequest())
            ->withNamespaceName(self::namespace2)
            ->withAccessToken(self::$accessToken0001)
            ->withFromUserId("user-0002")
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.RejectRequestRequest;
import io.gs2.friend.result.RejectRequestResult;

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

try {
    RejectRequestResult result = client.rejectRequest(
        new RejectRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withFromUserId("user-0002")
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.RejectRequestRequest;
using Gs2.Gs2Friend.Result.RejectRequestResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.RejectRequestResult> asyncResult = null;
yield return client.RejectRequest(
    new Gs2.Gs2Friend.Request.RejectRequestRequest()
        .WithNamespaceName("namespace2")
        .WithAccessToken("accessToken-0001")
        .WithFromUserId("user-0002"),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.rejectRequest(
        new Gs2Friend.RejectRequestRequest()
            .withNamespaceName("namespace2")
            .withAccessToken("accessToken-0001")
            .withFromUserId("user-0002")
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.reject_request(
        friend.RejectRequestRequest()
            .with_namespace_name(self.hash2)
            .with_access_token(self.access_token_0001)
            .with_from_user_id('user-0002')
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.reject_request({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    fromUserId="user-0002",
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.reject_request_async({
    namespaceName="namespace2",
    accessToken="accessToken-0001",
    fromUserId="user-0002",
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

rejectRequestByUserId

Reject friend requests by user ID

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
fromUserId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	FriendRequest	Rejected friend request

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.RejectRequestByUserId(
    &friend.RejectRequestByUserIdRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        FromUserId: pointy.String("user-0002"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\RejectRequestByUserIdRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->rejectRequestByUserId(
        (new RejectRequestByUserIdRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withFromUserId("user-0002")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.RejectRequestByUserIdRequest;
import io.gs2.friend.result.RejectRequestByUserIdResult;

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

try {
    RejectRequestByUserIdResult result = client.rejectRequestByUserId(
        new RejectRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withFromUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    FriendRequest item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.RejectRequestByUserIdRequest;
using Gs2.Gs2Friend.Result.RejectRequestByUserIdResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.RejectRequestByUserIdResult> asyncResult = null;
yield return client.RejectRequestByUserId(
    new Gs2.Gs2Friend.Request.RejectRequestByUserIdRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithFromUserId("user-0002")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.rejectRequestByUserId(
        new Gs2Friend.RejectRequestByUserIdRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withFromUserId("user-0002")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.reject_request_by_user_id(
        friend.RejectRequestByUserIdRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_from_user_id('user-0002')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.reject_request_by_user_id({
    namespaceName="namespace2",
    userId="user-0001",
    fromUserId="user-0002",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.reject_request_by_user_id_async({
    namespaceName="namespace2",
    userId="user-0001",
    fromUserId="user-0002",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

getPublicProfile

Request

	Type	Require	Limitation	Description
namespaceName	string	✓	~ 128 chars	Namespace name
userId	string	✓	~ 128 chars	User Id
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	PublicProfile	Public Profile

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/friend"
import "github.com/openlyinc/pointy"

session := core.Gs2RestSession{
    Credential: &core.BasicGs2Credential{
        ClientId: "your client id",
        ClientSecret: "your client secret",
    },
    Region: core.ApNortheast1,
}

if err := session.Connect(); err != nil {
    panic("error occurred")
}

client := friend.Gs2FriendRestClient{
    Session: &session,
}
result, err := client.GetPublicProfile(
    &friend.GetPublicProfileRequest {
        NamespaceName: pointy.String("namespace2"),
        UserId: pointy.String("user-0001"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Friend\Gs2FriendRestClient;
use Gs2\Friend\Request\GetPublicProfileRequest;

$session = new Gs2RestSession(
    new BasicGs2Credential(
        "your client id",
        "your client secret"
    ),
    Region::AP_NORTHEAST_1
);

$session->open();

$client = new Gs2AccountRestClient(
    $session
);

try {
    $result = $client->getPublicProfile(
        (new GetPublicProfileRequest())
            ->withNamespaceName(self::namespace2)
            ->withUserId("user-0001")
            ->withTimeOffsetToken(null)
    );
    $item = $result->getItem();
} catch (Gs2Exception $e) {
    exit("error occurred")
}

import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.friend.rest.Gs2FriendRestClient;
import io.gs2.friend.request.GetPublicProfileRequest;
import io.gs2.friend.result.GetPublicProfileResult;

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

try {
    GetPublicProfileResult result = client.getPublicProfile(
        new GetPublicProfileRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    PublicProfile item = result.getItem();
} catch (Gs2Exception e) {
    System.exit(1);
}

using Gs2.Core.Model.Region;
using Gs2.Core.Model.BasicGs2Credential;
using Gs2.Core.Net.Gs2RestSession;
using Gs2.Core.Exception.Gs2Exception;
using Gs2.Core.AsyncResult;
using Gs2.Gs2Friend.Gs2FriendRestClient;
using Gs2.Gs2Friend.Request.GetPublicProfileRequest;
using Gs2.Gs2Friend.Result.GetPublicProfileResult;

var session = new Gs2RestSession(
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    Region.ApNortheast1
);
yield return session.Open();
var client = new Gs2FriendRestClient(session);

AsyncResult<Gs2.Gs2Friend.Result.GetPublicProfileResult> asyncResult = null;
yield return client.GetPublicProfile(
    new Gs2.Gs2Friend.Request.GetPublicProfileRequest()
        .WithNamespaceName("namespace2")
        .WithUserId("user-0001")
        .WithTimeOffsetToken(null),
    r => asyncResult = r
);
if (asyncResult.Error != null) {
    throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;

import Gs2Core from '@/gs2/core';
import * as Gs2Friend from '@/gs2/friend';

const session = new Gs2Core.Gs2RestSession(
    "ap-northeast-1",
    new Gs2Core.BasicGs2Credential(
        'your client id',
        'your client secret'
    )
);
await session.connect();
const client = new Gs2Friend.Gs2FriendRestClient(session);

try {
    const result = await client.getPublicProfile(
        new Gs2Friend.GetPublicProfileRequest()
            .withNamespaceName("namespace2")
            .withUserId("user-0001")
            .withTimeOffsetToken(null)
    );
    const item = result.getItem();
} catch (e) {
    process.exit(1);
}

from gs2 import core
from gs2 import friend

session = core.Gs2RestSession(
    core.BasicGs2Credential(
        'your client id',
        'your client secret'
    ),
    "ap-northeast-1",
)
session.connect()
client = friend.Gs2FriendRestClient(session)

try:
    result = client.get_public_profile(
        friend.GetPublicProfileRequest()
            .with_namespace_name(self.hash2)
            .with_user_id('user-0001')
            .with_time_offset_token(None)
    )
    item = result.item
except core.Gs2Exception as e:
    exit(1)

client = gs2('friend')

api_result = client.get_public_profile({
    namespaceName="namespace2",
    userId="user-0001",
    timeOffsetToken=nil,
})

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;

client = gs2('friend')

api_result_handler = client.get_public_profile_async({
    namespaceName="namespace2",
    userId="user-0001",
    timeOffsetToken=nil,
})

api_result = api_result_handler()  -- Call the handler to get the result

if(api_result.isError) then
    -- When error occurs
    fail(api_result['statusCode'], api_result['message'])
end

result = api_result.result
item = result.item;