> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Chat SDK API Reference
Specification of models and API references for GS2-Chat SDK for various programming languages
## Models
### Namespace
Namespace
A Namespace allows multiple independent instances of the same service within a single project by separating data spaces and usage contexts.
Each GS2 service is managed on a per-namespace basis. Even when using the same service, if the Namespace differs, the data is treated as a completely independent data space.
Therefore, you must create a Namespace before you can start using each service.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | * | | ~ 1024 chars | Namespace GRN
* Set automatically by the server |
| name | string | | ✓ | | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| description | string | | | | ~ 1024 chars | Description |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | Transaction Setting
Configuration for controlling how transactions are processed within the chat service. |
| allowCreateRoom | bool | | | true | | Whether to allow game players to create rooms
If the game operator pre-creates rooms and players subscribe to them, specify “false”.
On the other hand, if the game player creates the rooms freely and invites other players to play, specify "true". |
| messageLifeTimeDays | int | | | 1 | 1 ~ 30 | Message retention period (days)
The number of days to keep messages in the room. |
| postMessageScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when a message is posted
Script Trigger Reference - [`postMessage`](../script/#postmessage) |
| createRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when a room is created
Script Trigger Reference - [`createRoom`](../script/#createroom) |
| deleteRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when a room is deleted
Script Trigger Reference - [`deleteRoom`](../script/#deleteroom) |
| subscribeRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when subscribing to a room
Script Trigger Reference - [`subscribeRoom`](../script/#subscriberoom) |
| unsubscribeRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when unsubscribing from a room
Script Trigger Reference - [`unsubscribeRoom`](../script/#unsubscriberoom) |
| postNotification | [NotificationSetting](#notificationsetting) | | ✓ | | | Push notifications when new posts are added to subscribed rooms
Configuration for sending push notifications via GS2-Gateway when a new message is posted to a subscribed room. Without this setting, clients must poll rooms to detect new messages. |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Manages log output settings. This type holds the GS2-Log Namespace information used to output log data. |
| createdAt | long | | * | Current time | | Creation Timestamp
Unix time, milliseconds
* Set automatically by the server |
| updatedAt | long | | * | Current time | | Last Updated Timestamp
Unix time, milliseconds
* Set automatically by the server |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | Revision |
**Related methods:**
describeNamespaces - List Namespaces
createNamespace - Create Namespace
getNamespace - Get Namespace
updateNamespace - Update Namespace
deleteNamespace - Delete Namespace
---
### TransactionSetting
Transaction Setting
Transaction Setting controls execution methods, consistency, asynchronous processing, and conflict avoidance mechanisms of transactions.
Combining features like AutoRun, AtomicCommit, asynchronous execution using GS2-Distributor, batch application of script results, and asynchronous processing of Acquire Actions via GS2-JobQueue enables robust transaction management tailored to game logic.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| enableAutoRun | bool | | | false | | Whether to automatically execute issued transactions on the server side |
| enableAtomicCommit | bool | {enableAutoRun} == true | | false | | Whether to commit transactions atomically
* Enabled only if enableAutoRun is true |
| transactionUseDistributor | bool | {enableAtomicCommit} == true | | false | | Whether to execute transactions asynchronously
* Enabled only if enableAtomicCommit is true |
| commitScriptResultInUseDistributor | bool | {transactionUseDistributor} == true | | false | | Whether to execute the commit processing of the script result asynchronously
* Enabled only if transactionUseDistributor is true |
| acquireActionUseJobQueue | bool | {enableAtomicCommit} == true | | false | | Whether to use GS2-JobQueue to execute the acquire action
* Enabled only if enableAtomicCommit is true |
| distributorNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:distributor:default" | ~ 1024 chars | GS2-Distributor Namespace GRN used to execute transactions |
| queueNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:queue:default" | ~ 1024 chars | GS2-JobQueue Namespace GRN used to execute transactions |
**Related methods:**
createNamespace - Create Namespace
updateNamespace - Update Namespace
**Related models:**
Namespace - Namespace
---
### ScriptSetting
Script Setting
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.
Because synchronous execution blocks processing until the script finishes executing,
you can use the script result to stop the API execution or control the API response.
In contrast, asynchronous execution does not block processing until the script has finished executing.
However, because the script result cannot be used to stop the API execution or modify the API response,
asynchronous execution does not affect the API response flow and is generally recommended.
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 | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| triggerScriptId | string | | | | ~ 1024 chars | GS2-Script script GRN executed synchronously when the API is executed
Must be specified in GRN format starting with "grn:gs2:". |
| doneTriggerTargetType | string (enum)
enum {
"none",
"gs2_script",
"aws"
}
| | | "none" | | Asynchronous script execution method
Specifies the type of script to use for asynchronous execution.
You can choose from "Do not use an asynchronous execution script (none)", "Use GS2-Script (gs2_script)", and "Use Amazon EventBridge (aws)"."none": None / "gs2_script": GS2-Script / "aws": Amazon EventBridge / |
| doneTriggerScriptId | string | {doneTriggerTargetType} == "gs2_script" | | | ~ 1024 chars | GS2-Script script GRN for asynchronous execution
Must be specified in GRN format starting with "grn:gs2:".
* Enabled only if doneTriggerTargetType is "gs2_script" |
| doneTriggerQueueNamespaceId | string | {doneTriggerTargetType} == "gs2_script" | | | ~ 1024 chars | GS2-JobQueue Namespace GRN used to execute asynchronous scripts
If you want to execute asynchronous execution scripts via GS2-JobQueue instead of executing them directly, specify the GS2-JobQueue Namespace GRN.
GS2-JobQueue is generally not required unless you have a specific reason to use it.
* Enabled only if doneTriggerTargetType is "gs2_script" |
**Related methods:**
createNamespace - Create Namespace
updateNamespace - Update Namespace
**Related models:**
Namespace - Namespace
---
### NotificationSetting
Push Notification Setting
Configuration for sending push notifications when events occur in GS2 microservices.
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 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 forward notifications to mobile push notification services when the destination device is offline.
By properly utilizing mobile push notifications, you can implement a flow in which players are notified even if they exit the game during matchmaking and later return to it.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| gatewayNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:gateway:default" | ~ 1024 chars | GS2-Gateway Namespace to use for push notifications
Specify the GS2-Gateway Namespace ID in GRN format starting with "grn:gs2:". |
| enableTransferMobileNotification | bool? | | | false | | Whether to forward the notification as a mobile push notification
When an attempt is made to send this notification and the destination device is offline, specify whether it should be forwarded as a mobile push notification. |
| sound | string | {enableTransferMobileNotification} == true | | | ~ 1024 chars | Sound file name to be used for mobile push notifications
The sound file name specified here is used when sending mobile push notifications, and you can send notifications with a special sound.
* Enabled only if enableTransferMobileNotification is true |
| enable | string (enum)
enum {
"Enabled",
"Disabled"
}
| | | "Enabled" | | Whether to enable push notifications"Enabled": Enabled / "Disabled": Disabled / |
**Related methods:**
createNamespace - Create Namespace
updateNamespace - Update Namespace
**Related models:**
Namespace - Namespace
---
### LogSetting
Log Output Setting
Log Output Setting defines how log data is exported. This type holds the GS2-Log Namespace identifier (Namespace ID), which is used to export log data.
Specify the GS2-Log Namespace where log data is collected and stored in the GRN format for the Log Namespace ID (loggingNamespaceId).
Configuring this setting ensures that log data for API requests and responses occurring within the specified Namespace is output to the target GS2-Log Namespace.
GS2-Log provides real-time logs that can be used for system monitoring, analysis, debugging, and other operational purposes.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| loggingNamespaceId | string | | ✓ | | ~ 1024 chars | GS2-Log Namespace GRN to output logs
Must be specified in GRN format starting with "grn:gs2:". |
**Related methods:**
createNamespace - Create Namespace
updateNamespace - Update Namespace
**Related models:**
Namespace - Namespace
---
### GitHubCheckoutSetting
Setting for checking out master data from GitHub
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| apiKeyId | string | | ✓ | | ~ 1024 chars | GitHub API Key GRN |
| repositoryName | string | | ✓ | | ~ 1024 chars | Repository Name |
| sourcePath | string | | ✓ | | ~ 1024 chars | Master data (JSON) file path |
| referenceType | string (enum)
enum {
"commit_hash",
"branch",
"tag"
}
| | ✓ | | | Source of code"commit_hash": Commit hash / "branch": Branch / "tag": Tag / |
| commitHash | string | {referenceType} == "commit_hash" | ✓* | | ~ 1024 chars | Commit hash
* Required if referenceType is "commit_hash" |
| branchName | string | {referenceType} == "branch" | ✓* | | ~ 1024 chars | Branch Name
* Required if referenceType is "branch" |
| tagName | string | {referenceType} == "tag" | ✓* | | ~ 1024 chars | Tag Name
* Required if referenceType is "tag" |
**Related methods:**
updateCurrentModelMasterFromGitHub - Update currently active Message Category Model master data from GitHub
---
### Room
Room
A room represents the scope within which chat messages can be delivered.
GS2-Chat rooms do not have the concept of participation.
Therefore, to receive messages, it is sufficient to know the room name, and there is no need to join the room or register as a member.
If you wish to limit the number of game players who can view the messages in a room, there are two options.
The first is to set a password for the room.
The second is to configure a whitelist for the room and restrict access by specifying user IDs.
Note that if you set a password, even the game administrator will not be able to retrieve messages without knowing the password.
This is because this may fall under the `secret of communication` stipulated in the Constitution of Japan.
If you subscribe to a room, you can receive GS2-Gateway push notifications when new messages are sent to the room.
By using this notification function, you will be able to know if there are any new messages without polling the room.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| roomId | string | | * | | ~ 1024 chars | Room GRN
* Set automatically by the server |
| name | string | | ✓ | UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| userId | string | | | | ~ 128 chars | Owner User ID
The user ID of the room owner. When set, only the owner can delete the room. Setting an owner is optional. |
| metadata | string | | | | ~ 1024 chars | Metadata
Arbitrary values can be set in the metadata.
Since they do not affect GS2’s behavior, they can be used to store information used in the game. |
| password | string | | | | ~ 128 chars | Password required to access the room
When set, the password must be provided to retrieve or post messages. The password value cannot be referenced again after setting. Even game administrators cannot access messages without the password, as this may fall under communication privacy protections. |
| whiteListUserIds | List<string> | | | [] | 0 ~ 1000 items | List of user IDs with access to the room
When set, only the listed users can retrieve and post messages in the room. If empty, access is not restricted by user ID (though a password may still be required). |
| createdAt | long | | * | Current time | | Creation Timestamp
Unix time, milliseconds
* Set automatically by the server |
| updatedAt | long | | * | Current time | | Last Updated Timestamp
Unix time, milliseconds
* Set automatically by the server |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | Revision |
**Related methods:**
describeRooms - List Rooms
createRoom - Create Room
createRoomFromBackend - Create Room from Backend
getRoom - Get Room Information
updateRoom - Update Room
updateRoomFromBackend - Update Room from Backend
deleteRoom - Delete Room
deleteRoomFromBackend - Delete Room from Backend
---
### Message
Message
A message is data posted in a room.
It has a field called category, which allows classification of messages.
For example, a category of 0 is interpreted as a normal text message, while a category of 1 can be processed as a stamp (sticker).
Messages posted will be automatically deleted after the message retention period set in the Chat Namespace's messageLifeTimeDays setting has elapsed.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| messageId | string | | * | | ~ 1024 chars | Message GRN
* Set automatically by the server |
| roomName | string | | ✓ | UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| name | string | | ✓ | UUID | ~ 36 chars | Message name
Maintains a unique name for each message.
Names are automatically generated in UUID (Universally Unique Identifier) format and used to identify each message. |
| userId | string | | ✓ | | ~ 128 chars | User ID |
| category | int | | | 0 | 0 ~ 2147483645 | Category number for classifying messages
A numeric value used to classify messages. For example, 0 can represent text messages, 1 can represent stamps/stickers, and other values can represent custom message types. The category determines which CategoryModel rules apply to the message. |
| metadata | string | | ✓ | | ~ 1024 chars | Metadata
Arbitrary values can be set in the metadata.
Since they do not affect GS2’s behavior, they can be used to store information used in the game. |
| createdAt | long | | * | Current time | | Creation Timestamp
Unix time, milliseconds
* Set automatically by the server |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | Revision |
**Related methods:**
describeMessages - List Messages
describeMessagesByUserId - List Messages by User ID
describeLatestMessages - List latest Messages
describeLatestMessagesByUserId - List latest Messages by User ID
post - Post a message
postByUserId - Post Message by User ID
getMessage - Get Message
getMessageByUserId - Get Message by User ID
deleteMessage - Delete message
---
### Subscribe
Room Subscription
By subscribing to a room, you will be instantly informed of new messages for that room.
When subscribing, you can specify the category of the message.
This feature can be used to receive only high-priority messages.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| subscribeId | string | | * | | ~ 1024 chars | Subscription GRN
* Set automatically by the server |
| userId | string | | ✓ | | ~ 128 chars | User ID |
| roomName | string | | ✓ | | ~ 128 chars | Room name to subscribe to
The name of the chat room to subscribe to. When subscribed, push notifications are sent via GS2-Gateway whenever new messages are posted to this room. |
| notificationTypes | [List<NotificationType>](#notificationtype) | | | [] | 0 ~ 100 items | List of categories to receive notifications of new messages
Filters which message categories trigger push notifications. If empty, notifications are sent for all categories. Each entry specifies a category number and optional mobile push notification forwarding. |
| createdAt | long | | * | Current time | | Creation Timestamp
Unix time, milliseconds
* Set automatically by the server |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | Revision |
**Related methods:**
describeSubscribes - List Room Subscriptions
describeSubscribesByUserId - List Room Subscriptions by User ID
describeSubscribesByRoomName - List users subscribed to a room by specifying Room name
subscribe - Subscribe to a room
subscribeByUserId - Subscribe to a room by User ID
getSubscribe - Get Room Subscription
getSubscribeByUserId - Get Room Subscription by User ID
updateNotificationType - Update notification methods
updateNotificationTypeByUserId - Update notification methods by User ID
unsubscribe - Unsubscribe from a room
unsubscribeByUserId - Unsubscribe from a subscription by User ID
---
### CategoryModel
Message Category Model
A Message Category Model defines the categories used to classify messages posted in chat rooms.
Each category is identified by a numeric value, and you can configure whether posts using player access tokens are accepted or rejected per category.
This enables use cases such as system-only announcement categories where only the server can post messages.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| categoryModelId | string | | * | | ~ 1024 chars | Message Category Model GRN
* Set automatically by the server |
| category | int | | ✓ | | 0 ~ 2147483645 | Category
A numeric identifier for the message category. Messages posted with this category number will follow the rules defined in this model, such as whether player posts are allowed or rejected. |
| rejectAccessTokenPost | string (enum)
enum {
"Enabled",
"Disabled"
}
| | | | | Reject posts made using player access tokens
When enabled, only server-side API calls specifying a user ID can post messages in this category. This is useful for system announcements or server-generated messages that should not be posted by players directly."Enabled": Reject posts made using player access tokens / "Disabled": Allow posts made using player access tokens / |
**Related methods:**
describeCategoryModels - List Message Category Models
getCategoryModel - Get Message Category Model
---
### NotificationType
Notification Type
Configuration of categories for receiving new message notifications
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| category | int | | | 0 | 0 ~ 2147483646 | Categories for which you receive new message notifications
The numeric category identifier to filter notifications. Only messages matching this category will trigger a push notification for the subscription. |
| enableTransferMobilePushNotification | bool | | | false | | Whether to forward to mobile push notifications when offline
When enabled, if the recipient device is offline at the time of notification, the notification is forwarded to the mobile push notification service. This allows players to be notified of new messages even when the game is not running. |
**Related models:**
Subscribe - Room Subscription
---
### CurrentModelMaster
Currently active Message Category Model master data
This master data defines the Message Category Models currently active within the Namespace.
GS2 uses JSON format files for managing master data.
By uploading these files, you can apply the master data to the server.
To create JSON files, GS2 provides a master data editor within the management console.
Additionally, you can create tools better suited for game operations and export JSON files in the appropriate format.
{{% alert title="Note" color="info" %}}
Please refer to [GS2-Chat Master Data Reference](api_reference/chat/master_data/) for the JSON file format.
{{% /alert %}}
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | * | | ~ 1024 chars | Namespace GRN
* Set automatically by the server |
| settings | string | | ✓ | | ~ 5242880 bytes (5MB) | Master data |
**Related methods:**
exportMaster - Export Message Category Model Master in a master data format that can be activated
getCurrentModelMaster - Get currently active Message Category Model master data
updateCurrentModelMaster - Update currently active Message Category Model master data
updateCurrentModelMasterFromGitHub - Update currently active Message Category Model master data from GitHub
---
### CategoryModelMaster
Message Category Model Master
Message Category Model Master is data used to edit and Manage Category Model within the game. It is temporarily stored in the Management Console's Master Data Editor.
By performing import and update processes, it is reflected as Message Category Model actually referenced by the game.
Message Category Model is the setting for the categories to be posted in the room.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| categoryModelId | string | | * | | ~ 1024 chars | Message Category Model Master GRN
* Set automatically by the server |
| category | int | | ✓ | | 0 ~ 2147483645 | Category
A numeric identifier for the message category. Messages posted with this category number will follow the rules defined in this model, such as whether player posts are allowed or rejected. |
| description | string | | | | ~ 1024 chars | Description |
| rejectAccessTokenPost | string (enum)
enum {
"Enabled",
"Disabled"
}
| | | | | Reject posts made using player access tokens
When enabled, only server-side API calls specifying a user ID can post messages in this category. This is useful for system announcements or server-generated messages that should not be posted by players directly."Enabled": Reject posts made using player access tokens / "Disabled": Allow posts made using player access tokens / |
| createdAt | long | | * | Current time | | Creation Timestamp
Unix time, milliseconds
* Set automatically by the server |
| updatedAt | long | | * | Current time | | Last Updated Timestamp
Unix time, milliseconds
* Set automatically by the server |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | Revision |
**Related methods:**
describeCategoryModelMasters - List Message Category Model Masters
createCategoryModelMaster - Create Message Category Model Master
getCategoryModelMaster - Get Message Category Model Master
updateCategoryModelMaster - Update Message Category Model Master
deleteCategoryModelMaster - Delete Message Category Model Master
---
## Methods
### describeNamespaces
List Namespaces
Retrieves a list of Namespaces that have been created on a per-service basis within the project.
You can use the optional page token to start acquiring data from a specific location in the list.
You can also limit the number of Namespaces to be acquired.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namePrefix | string | | | | ~ 64 chars | Filter by Namespace name prefix |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Namespace>](#namespace) | List of Namespaces |
| nextPageToken | string | Page token to retrieve the rest of the listing |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&chat.DescribeNamespacesRequest {
NamePrefix: nil,
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeNamespaces(
(new DescribeNamespacesRequest())
->withNamePrefix(null)
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeNamespacesRequest;
import io.gs2.chat.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeNamespacesResult result = client.describeNamespaces(
new DescribeNamespacesRequest()
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2Chat.Request.DescribeNamespacesRequest()
.WithNamePrefix(null)
.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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2Chat.DescribeNamespacesRequest()
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_namespaces(
chat.DescribeNamespacesRequest()
.with_name_prefix(None)
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_namespaces({
namePrefix=nil,
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_namespaces_async({
namePrefix=nil,
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createNamespace
Create Namespace
You must specify detailed information including the name, description, and various settings of the Namespace.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| description | string | | | | ~ 1024 chars | Description |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | Transaction Setting
Configuration for controlling how transactions are processed within the chat service. |
| allowCreateRoom | bool | | | true | | Whether to allow game players to create rooms
If the game operator pre-creates rooms and players subscribe to them, specify “false”.
On the other hand, if the game player creates the rooms freely and invites other players to play, specify "true". |
| messageLifeTimeDays | int | | | 1 | 1 ~ 30 | Message retention period (days)
The number of days to keep messages in the room. |
| postMessageScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when a message is posted
Script Trigger Reference - [`postMessage`](../script/#postmessage) |
| createRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when a room is created
Script Trigger Reference - [`createRoom`](../script/#createroom) |
| deleteRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when a room is deleted
Script Trigger Reference - [`deleteRoom`](../script/#deleteroom) |
| subscribeRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when subscribing to a room
Script Trigger Reference - [`subscribeRoom`](../script/#subscriberoom) |
| unsubscribeRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when unsubscribing from a room
Script Trigger Reference - [`unsubscribeRoom`](../script/#unsubscriberoom) |
| postNotification | [NotificationSetting](#notificationsetting) | | ✓| | | Push notifications when new posts are added to subscribed rooms
Configuration for sending push notifications via GS2-Gateway when a new message is posted to a subscribed room. Without this setting, clients must poll rooms to detect new messages. |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Manages log output settings. This type holds the GS2-Log Namespace information used to output log data. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Namespace](#namespace) | Namespace created |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&chat.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
TransactionSetting: nil,
AllowCreateRoom: nil,
MessageLifeTimeDays: nil,
PostMessageScript: nil,
CreateRoomScript: nil,
DeleteRoomScript: nil,
SubscribeRoomScript: nil,
UnsubscribeRoomScript: nil,
PostNotification: nil,
LogSetting: &chat.LogSetting{
LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting(null)
->withAllowCreateRoom(null)
->withMessageLifeTimeDays(null)
->withPostMessageScript(null)
->withCreateRoomScript(null)
->withDeleteRoomScript(null)
->withSubscribeRoomScript(null)
->withUnsubscribeRoomScript(null)
->withPostNotification(null)
->withLogSetting((new \Gs2\Chat\Model\LogSetting())
->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.CreateNamespaceRequest;
import io.gs2.chat.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(null)
.withAllowCreateRoom(null)
.withMessageLifeTimeDays(null)
.withPostMessageScript(null)
.withCreateRoomScript(null)
.withDeleteRoomScript(null)
.withSubscribeRoomScript(null)
.withUnsubscribeRoomScript(null)
.withPostNotification(null)
.withLogSetting(new io.gs2.chat.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2Chat.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(null)
.WithAllowCreateRoom(null)
.WithMessageLifeTimeDays(null)
.WithPostMessageScript(null)
.WithCreateRoomScript(null)
.WithDeleteRoomScript(null)
.WithSubscribeRoomScript(null)
.WithUnsubscribeRoomScript(null)
.WithPostNotification(null)
.WithLogSetting(new Gs2.Gs2Chat.Model.LogSetting()
.WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.createNamespace(
new Gs2Chat.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(null)
.withAllowCreateRoom(null)
.withMessageLifeTimeDays(null)
.withPostMessageScript(null)
.withCreateRoomScript(null)
.withDeleteRoomScript(null)
.withSubscribeRoomScript(null)
.withUnsubscribeRoomScript(null)
.withPostNotification(null)
.withLogSetting(new Gs2Chat.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.create_namespace(
chat.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_transaction_setting(None)
.with_allow_create_room(None)
.with_message_life_time_days(None)
.with_post_message_script(None)
.with_create_room_script(None)
.with_delete_room_script(None)
.with_subscribe_room_script(None)
.with_unsubscribe_room_script(None)
.with_post_notification(None)
.with_log_setting(
chat.LogSetting()
.with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
transactionSetting=nil,
allowCreateRoom=nil,
messageLifeTimeDays=nil,
postMessageScript=nil,
createRoomScript=nil,
deleteRoomScript=nil,
subscribeRoomScript=nil,
unsubscribeRoomScript=nil,
postNotification=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
transactionSetting=nil,
allowCreateRoom=nil,
messageLifeTimeDays=nil,
postMessageScript=nil,
createRoomScript=nil,
deleteRoomScript=nil,
subscribeRoomScript=nil,
unsubscribeRoomScript=nil,
postNotification=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getNamespaceStatus
Get Namespace Status
Get the current status of the specified Namespace.
This includes whether the Namespace is active, pending, or in some other state.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| status | string | |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&chat.GetNamespaceStatusRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
status := result.Status
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getNamespaceStatus(
(new GetNamespaceStatusRequest())
->withNamespaceName("namespace-0001")
);
$status = $result->getStatus();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetNamespaceStatusRequest;
import io.gs2.chat.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetNamespaceStatusResult result = client.getNamespaceStatus(
new GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
String status = result.getStatus();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2Chat.Request.GetNamespaceStatusRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var status = result.Status;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2Chat.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_namespace_status(
chat.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_namespace_status({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
status = result.status;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_namespace_status_async({
namespaceName="namespace-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['errorMessage'])
end
result = api_result.result
status = result.status;
```
---
### getNamespace
Get Namespace
Get detailed information about the specified Namespace.
This includes the name, description, and other settings of the Namespace.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Namespace](#namespace) | Namespace |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&chat.GetNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getNamespace(
(new GetNamespaceRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetNamespaceRequest;
import io.gs2.chat.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetNamespaceResult result = client.getNamespace(
new GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2Chat.Request.GetNamespaceRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getNamespace(
new Gs2Chat.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_namespace(
chat.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_namespace({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_namespace_async({
namespaceName="namespace-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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateNamespace
Update Namespace
Update the settings of the specified Namespace.
You can change the description and other settings of the Namespace.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| description | string | | | | ~ 1024 chars | Description |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | Transaction Setting
Configuration for controlling how transactions are processed within the chat service. |
| allowCreateRoom | bool | | | true | | Whether to allow game players to create rooms
If the game operator pre-creates rooms and players subscribe to them, specify “false”.
On the other hand, if the game player creates the rooms freely and invites other players to play, specify "true". |
| messageLifeTimeDays | int | | | 1 | 1 ~ 30 | Message retention period (days)
The number of days to keep messages in the room. |
| postMessageScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when a message is posted
Script Trigger Reference - [`postMessage`](../script/#postmessage) |
| createRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when a room is created
Script Trigger Reference - [`createRoom`](../script/#createroom) |
| deleteRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when a room is deleted
Script Trigger Reference - [`deleteRoom`](../script/#deleteroom) |
| subscribeRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when subscribing to a room
Script Trigger Reference - [`subscribeRoom`](../script/#subscriberoom) |
| unsubscribeRoomScript | [ScriptSetting](#scriptsetting) | | | | | Script setting to be executed when unsubscribing from a room
Script Trigger Reference - [`unsubscribeRoom`](../script/#unsubscriberoom) |
| postNotification | [NotificationSetting](#notificationsetting) | | ✓| | | Push notifications when new posts are added to subscribed rooms
Configuration for sending push notifications via GS2-Gateway when a new message is posted to a subscribed room. Without this setting, clients must poll rooms to detect new messages. |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Manages log output settings. This type holds the GS2-Log Namespace information used to output log data. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Namespace](#namespace) | Namespace updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&chat.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
TransactionSetting: nil,
AllowCreateRoom: pointy.Bool(false),
MessageLifeTimeDays: nil,
PostMessageScript: nil,
CreateRoomScript: nil,
DeleteRoomScript: nil,
SubscribeRoomScript: nil,
UnsubscribeRoomScript: nil,
PostNotification: nil,
LogSetting: &chat.LogSetting{
LoggingNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"),
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting(null)
->withAllowCreateRoom(false)
->withMessageLifeTimeDays(null)
->withPostMessageScript(null)
->withCreateRoomScript(null)
->withDeleteRoomScript(null)
->withSubscribeRoomScript(null)
->withUnsubscribeRoomScript(null)
->withPostNotification(null)
->withLogSetting((new \Gs2\Chat\Model\LogSetting())
->withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.UpdateNamespaceRequest;
import io.gs2.chat.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(null)
.withAllowCreateRoom(false)
.withMessageLifeTimeDays(null)
.withPostMessageScript(null)
.withCreateRoomScript(null)
.withDeleteRoomScript(null)
.withSubscribeRoomScript(null)
.withUnsubscribeRoomScript(null)
.withPostNotification(null)
.withLogSetting(new io.gs2.chat.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2Chat.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(null)
.WithAllowCreateRoom(false)
.WithMessageLifeTimeDays(null)
.WithPostMessageScript(null)
.WithCreateRoomScript(null)
.WithDeleteRoomScript(null)
.WithSubscribeRoomScript(null)
.WithUnsubscribeRoomScript(null)
.WithPostNotification(null)
.WithLogSetting(new Gs2.Gs2Chat.Model.LogSetting()
.WithLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001")),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2Chat.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(null)
.withAllowCreateRoom(false)
.withMessageLifeTimeDays(null)
.withPostMessageScript(null)
.withCreateRoomScript(null)
.withDeleteRoomScript(null)
.withSubscribeRoomScript(null)
.withUnsubscribeRoomScript(null)
.withPostNotification(null)
.withLogSetting(new Gs2Chat.model.LogSetting()
.withLoggingNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001"))
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.update_namespace(
chat.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_transaction_setting(None)
.with_allow_create_room(False)
.with_message_life_time_days(None)
.with_post_message_script(None)
.with_create_room_script(None)
.with_delete_room_script(None)
.with_subscribe_room_script(None)
.with_unsubscribe_room_script(None)
.with_post_notification(None)
.with_log_setting(
chat.LogSetting()
.with_logging_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001'))
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
transactionSetting=nil,
allowCreateRoom=false,
messageLifeTimeDays=nil,
postMessageScript=nil,
createRoomScript=nil,
deleteRoomScript=nil,
subscribeRoomScript=nil,
unsubscribeRoomScript=nil,
postNotification=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
transactionSetting=nil,
allowCreateRoom=false,
messageLifeTimeDays=nil,
postMessageScript=nil,
createRoomScript=nil,
deleteRoomScript=nil,
subscribeRoomScript=nil,
unsubscribeRoomScript=nil,
postNotification=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteNamespace
Delete Namespace
Delete the specified Namespace.
This operation is irreversible and all data associated with the deleted Namespace will be lost.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Namespace](#namespace) | Deleted Namespace |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&chat.DeleteNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->deleteNamespace(
(new DeleteNamespaceRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DeleteNamespaceRequest;
import io.gs2.chat.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DeleteNamespaceResult result = client.deleteNamespace(
new DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
Namespace item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2Chat.Request.DeleteNamespaceRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2Chat.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.delete_namespace(
chat.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.delete_namespace({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.delete_namespace_async({
namespaceName="namespace-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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getServiceVersion
Get microservice version
#### Request
Request parameters: None
#### Result
| | Type | Description |
| --- | --- | --- |
| item | string | Version |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&chat.GetServiceVersionRequest {
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getServiceVersion(
(new GetServiceVersionRequest())
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetServiceVersionRequest;
import io.gs2.chat.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetServiceVersionResult result = client.getServiceVersion(
new GetServiceVersionRequest()
);
String item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2Chat.Request.GetServiceVersionRequest(),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2Chat.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_service_version(
chat.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_service_version({
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_service_version_async({
})
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### dumpUserDataByUserId
Dump data associated with the specified user ID
Can be used to meet legal requirements for the protection of personal information, or to back up or migrate data.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&chat.DumpUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->dumpUserDataByUserId(
(new DumpUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DumpUserDataByUserIdRequest;
import io.gs2.chat.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DumpUserDataByUserIdResult result = client.dumpUserDataByUserId(
new DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2Chat.Request.DumpUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2Chat.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.dump_user_data_by_user_id(
chat.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
```
---
### checkDumpUserDataByUserId
Check if the dump of the data associated with the specified user ID is complete
#### Request
| | Type | Condition | Required | Default | Value Limits | 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
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&chat.CheckDumpUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
url := result.Url
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->checkDumpUserDataByUserId(
(new CheckDumpUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$url = $result->getUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.chat.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
CheckDumpUserDataByUserIdResult result = client.checkDumpUserDataByUserId(
new CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
String url = result.getUrl();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2Chat.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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2Chat.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
chat.CheckDumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
url = result.url
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
url = result.url;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
url = result.url;
```
---
### cleanUserDataByUserId
Delete user data
Execute cleaning of data associated with the specified user ID
This allows you to safely delete specific user data from the project.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&chat.CleanUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->cleanUserDataByUserId(
(new CleanUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.CleanUserDataByUserIdRequest;
import io.gs2.chat.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
CleanUserDataByUserIdResult result = client.cleanUserDataByUserId(
new CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2Chat.Request.CleanUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2Chat.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.clean_user_data_by_user_id(
chat.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
```
---
### checkCleanUserDataByUserId
Check if the cleaning of the data associated with the specified user ID is complete
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&chat.CheckCleanUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->checkCleanUserDataByUserId(
(new CheckCleanUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.chat.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
CheckCleanUserDataByUserIdResult result = client.checkCleanUserDataByUserId(
new CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2Chat.Request.CheckCleanUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2Chat.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
chat.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
```
---
### prepareImportUserDataByUserId
Prepare User Data Import by User ID
The data that can be used for import is limited to the data exported by GS2, and old data may fail to import.
You can import data with a user ID different from the one you exported, but if the user ID is included in the payload of the user data, this may not be the case.
You can start the actual import process by uploading the exported zip file to the URL returned in the return value of this API and calling importUserDataByUserId.
#### Request
| | Type | Condition | Required | Default | Value Limits | 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
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&chat.PrepareImportUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->prepareImportUserDataByUserId(
(new PrepareImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$uploadToken = $result->getUploadToken();
$uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.chat.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2Chat.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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2Chat.PrepareImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const uploadToken = result.getUploadToken();
const uploadUrl = result.getUploadUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
chat.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)
```
**GS2-Script**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
---
### importUserDataByUserId
Execute import of data associated with the specified user ID
The data that can be used for import is limited to the data exported by GS2, and old data may fail to import.
You can import data with a user ID different from the one you exported, but if the user ID is included in the payload of the user data, this may not be the case.
Before calling this API, you must call prepareImportUserDataByUserId to complete the upload preparation.
#### Request
| | Type | Condition | Required | Default | Value Limits | 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
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&chat.ImportUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
UploadToken: pointy.String("upload-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->importUserDataByUserId(
(new ImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withUploadToken("upload-0001")
->withTimeOffsetToken(null)
);
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.ImportUserDataByUserIdRequest;
import io.gs2.chat.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
ImportUserDataByUserIdResult result = client.importUserDataByUserId(
new ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2Chat.Request.ImportUserDataByUserIdRequest()
.WithUserId("user-0001")
.WithUploadToken("upload-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2Chat.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.import_user_data_by_user_id(
chat.ImportUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_upload_token('upload-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
```
---
### checkImportUserDataByUserId
Check if the import of the data associated with the specified user ID is complete
#### Request
| | Type | Condition | Required | Default | Value Limits | 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
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&chat.CheckImportUserDataByUserIdRequest {
UserId: pointy.String("user-0001"),
UploadToken: pointy.String("upload-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
url := result.Url
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->checkImportUserDataByUserId(
(new CheckImportUserDataByUserIdRequest())
->withUserId("user-0001")
->withUploadToken("upload-0001")
->withTimeOffsetToken(null)
);
$url = $result->getUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.CheckImportUserDataByUserIdRequest;
import io.gs2.chat.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(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);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2Chat.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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2Chat.CheckImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.check_import_user_data_by_user_id(
chat.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)
```
**GS2-Script**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
url = result.url;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
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['errorMessage'])
end
result = api_result.result
url = result.url;
```
---
### describeRooms
List Rooms
You can get a list of Room Information by specifying a page token and a limit on the number of acquisitions.
This allows you to check the overview of existing rooms.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| namePrefix | string | | | | ~ 64 chars | Filter by Namespace name prefix |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Room>](#room) | List of Room Information |
| nextPageToken | string | Page token to retrieve the rest of the listing |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeRooms(
&chat.DescribeRoomsRequest {
NamespaceName: pointy.String("namespace-0001"),
NamePrefix: nil,
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeRoomsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeRooms(
(new DescribeRoomsRequest())
->withNamespaceName("namespace-0001")
->withNamePrefix(null)
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeRoomsRequest;
import io.gs2.chat.result.DescribeRoomsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeRoomsResult result = client.describeRooms(
new DescribeRoomsRequest()
.withNamespaceName("namespace-0001")
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeRooms(
new Gs2.Gs2Chat.Request.DescribeRoomsRequest()
.WithNamespaceName("namespace-0001")
.WithNamePrefix(null)
.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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeRooms(
new Gs2Chat.DescribeRoomsRequest()
.withNamespaceName("namespace-0001")
.withNamePrefix(null)
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_rooms(
chat.DescribeRoomsRequest()
.with_namespace_name('namespace-0001')
.with_name_prefix(None)
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_rooms({
namespaceName="namespace-0001",
namePrefix=nil,
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_rooms_async({
namespaceName="namespace-0001",
namePrefix=nil,
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createRoom
Create Room
You can create a room by specifying a room name, user ID, metadata, password, and user ID to be registered in the whitelist.
The room name is optional, and if omitted, a UUID (Universally Unique Identifier) will be automatically assigned.
It is used to create a new communication space.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| accessToken | string | | ✓| | ~ 128 chars | Access token
The user ID of the room owner. When set, only the owner can delete the room. Setting an owner is optional. |
| name | string | | | UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| metadata | string | | | | ~ 1024 chars | Metadata
Arbitrary values can be set in the metadata.
Since they do not affect GS2’s behavior, they can be used to store information used in the game. |
| password | string | | | | ~ 128 chars | Password required to access the room
When set, the password must be provided to retrieve or post messages. The password value cannot be referenced again after setting. Even game administrators cannot access messages without the password, as this may fall under communication privacy protections. |
| whiteListUserIds | List<string> | | | [] | 0 ~ 1000 items | List of user IDs with access to the room
When set, only the listed users can retrieve and post messages in the room. If empty, access is not restricted by user ID (though a password may still be required). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Room](#room) | Room created |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.CreateRoom(
&chat.CreateRoomRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
Name: pointy.String("room-0001"),
Metadata: nil,
Password: nil,
WhiteListUserIds: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\CreateRoomRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->createRoom(
(new CreateRoomRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withName("room-0001")
->withMetadata(null)
->withPassword(null)
->withWhiteListUserIds(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.CreateRoomRequest;
import io.gs2.chat.result.CreateRoomResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
CreateRoomResult result = client.createRoom(
new CreateRoomRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withName("room-0001")
.withMetadata(null)
.withPassword(null)
.withWhiteListUserIds(null)
);
Room item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateRoom(
new Gs2.Gs2Chat.Request.CreateRoomRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithName("room-0001")
.WithMetadata(null)
.WithPassword(null)
.WithWhiteListUserIds(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.createRoom(
new Gs2Chat.CreateRoomRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withName("room-0001")
.withMetadata(null)
.withPassword(null)
.withWhiteListUserIds(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.create_room(
chat.CreateRoomRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_name('room-0001')
.with_metadata(None)
.with_password(None)
.with_white_list_user_ids(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.create_room({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
name="room-0001",
metadata=nil,
password=nil,
whiteListUserIds=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.create_room_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
name="room-0001",
metadata=nil,
password=nil,
whiteListUserIds=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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### createRoomFromBackend
Create Room from Backend
This API is not called by game players, but is used when creating rooms related to the system.
You can create a room by specifying a room name, user ID, metadata, password, and user ID to be registered in the whitelist.
The room name is optional, and if omitted, a UUID (Universally Unique Identifier) will be automatically assigned.
It is used to create a new communication space.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| name | string | | | UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| userId | string | | | | ~ 128 chars | Owner User ID
The user ID of the room owner. When set, only the owner can delete the room. Setting an owner is optional. |
| metadata | string | | | | ~ 1024 chars | Metadata
Arbitrary values can be set in the metadata.
Since they do not affect GS2’s behavior, they can be used to store information used in the game. |
| password | string | | | | ~ 128 chars | Password required to access the room
When set, the password must be provided to retrieve or post messages. The password value cannot be referenced again after setting. Even game administrators cannot access messages without the password, as this may fall under communication privacy protections. |
| whiteListUserIds | List<string> | | | [] | 0 ~ 1000 items | List of user IDs with access to the room
When set, only the listed users can retrieve and post messages in the room. If empty, access is not restricted by user ID (though a password may still be required). |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Room](#room) | Room created |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.CreateRoomFromBackend(
&chat.CreateRoomFromBackendRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("room-0001"),
UserId: nil,
Metadata: nil,
Password: nil,
WhiteListUserIds: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\CreateRoomFromBackendRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->createRoomFromBackend(
(new CreateRoomFromBackendRequest())
->withNamespaceName("namespace-0001")
->withName("room-0001")
->withUserId(null)
->withMetadata(null)
->withPassword(null)
->withWhiteListUserIds(null)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.CreateRoomFromBackendRequest;
import io.gs2.chat.result.CreateRoomFromBackendResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
CreateRoomFromBackendResult result = client.createRoomFromBackend(
new CreateRoomFromBackendRequest()
.withNamespaceName("namespace-0001")
.withName("room-0001")
.withUserId(null)
.withMetadata(null)
.withPassword(null)
.withWhiteListUserIds(null)
.withTimeOffsetToken(null)
);
Room item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateRoomFromBackend(
new Gs2.Gs2Chat.Request.CreateRoomFromBackendRequest()
.WithNamespaceName("namespace-0001")
.WithName("room-0001")
.WithUserId(null)
.WithMetadata(null)
.WithPassword(null)
.WithWhiteListUserIds(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.createRoomFromBackend(
new Gs2Chat.CreateRoomFromBackendRequest()
.withNamespaceName("namespace-0001")
.withName("room-0001")
.withUserId(null)
.withMetadata(null)
.withPassword(null)
.withWhiteListUserIds(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.create_room_from_backend(
chat.CreateRoomFromBackendRequest()
.with_namespace_name('namespace-0001')
.with_name('room-0001')
.with_user_id(None)
.with_metadata(None)
.with_password(None)
.with_white_list_user_ids(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.create_room_from_backend({
namespaceName="namespace-0001",
name="room-0001",
userId=nil,
metadata=nil,
password=nil,
whiteListUserIds=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.create_room_from_backend_async({
namespaceName="namespace-0001",
name="room-0001",
userId=nil,
metadata=nil,
password=nil,
whiteListUserIds=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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getRoom
Get Room Information
Retrieves detailed information about a specific room by name in the specified Namespace.
The retrieved information includes the room's metadata, the user ID of the creator, and whitelist settings.
No password validation is required for this operation; the password is not exposed in the response.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Room](#room) | Room |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetRoom(
&chat.GetRoomRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetRoomRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getRoom(
(new GetRoomRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetRoomRequest;
import io.gs2.chat.result.GetRoomResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetRoomResult result = client.getRoom(
new GetRoomRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
);
Room item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetRoom(
new Gs2.Gs2Chat.Request.GetRoomRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getRoom(
new Gs2Chat.GetRoomRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_room(
chat.GetRoomRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_room({
namespaceName="namespace-0001",
roomName="room-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_room_async({
namespaceName="namespace-0001",
roomName="room-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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateRoom
Update Room
Updates the specified room's metadata, password, and whitelist settings.
Only the room creator (the user who originally created the room) or a user listed in the whitelist can perform this operation.
An error is returned if the currently logged-in user does not have write permission on the room.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| metadata | string | | | | ~ 1024 chars | Metadata
Arbitrary values can be set in the metadata.
Since they do not affect GS2’s behavior, they can be used to store information used in the game. |
| password | string | | | | ~ 128 chars | Password required to access the room
When set, the password must be provided to retrieve or post messages. The password value cannot be referenced again after setting. Even game administrators cannot access messages without the password, as this may fall under communication privacy protections. |
| whiteListUserIds | List<string> | | | [] | 0 ~ 1000 items | List of user IDs with access to the room
When set, only the listed users can retrieve and post messages in the room. If empty, access is not restricted by user ID (though a password may still be required). |
| accessToken | string | | ✓| | ~ 128 chars | Access token
The user ID of the room owner. When set, only the owner can delete the room. Setting an owner is optional. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Room](#room) | Rooms updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.UpdateRoom(
&chat.UpdateRoomRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
Metadata: nil,
Password: pointy.String("password-0002"),
WhiteListUserIds: []*string{
pointy.String("user-0001"),
pointy.String("user-0002"),
pointy.String("user-0003"),
},
AccessToken: pointy.String("accessToken-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\UpdateRoomRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->updateRoom(
(new UpdateRoomRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withMetadata(null)
->withPassword("password-0002")
->withWhiteListUserIds([
"user-0001",
"user-0002",
"user-0003",
])
->withAccessToken("accessToken-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.UpdateRoomRequest;
import io.gs2.chat.result.UpdateRoomResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
UpdateRoomResult result = client.updateRoom(
new UpdateRoomRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withMetadata(null)
.withPassword("password-0002")
.withWhiteListUserIds(Arrays.asList(
"user-0001",
"user-0002",
"user-0003"
))
.withAccessToken("accessToken-0001")
);
Room item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateRoom(
new Gs2.Gs2Chat.Request.UpdateRoomRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithMetadata(null)
.WithPassword("password-0002")
.WithWhiteListUserIds(new string[] {
"user-0001",
"user-0002",
"user-0003",
})
.WithAccessToken("accessToken-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.updateRoom(
new Gs2Chat.UpdateRoomRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withMetadata(null)
.withPassword("password-0002")
.withWhiteListUserIds([
"user-0001",
"user-0002",
"user-0003",
])
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.update_room(
chat.UpdateRoomRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_metadata(None)
.with_password('password-0002')
.with_white_list_user_ids([
'user-0001',
'user-0002',
'user-0003',
])
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.update_room({
namespaceName="namespace-0001",
roomName="room-0001",
metadata=nil,
password="password-0002",
whiteListUserIds={
"user-0001",
"user-0002",
"user-0003"
},
accessToken="accessToken-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.update_room_async({
namespaceName="namespace-0001",
roomName="room-0001",
metadata=nil,
password="password-0002",
whiteListUserIds={
"user-0001",
"user-0002",
"user-0003"
},
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateRoomFromBackend
Update Room from Backend
Updates the specified room's metadata, password, and whitelist settings from the server side.
Unlike the player-facing update API, this does not validate write permission against the access token, as it is intended for system-level operations.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| metadata | string | | | | ~ 1024 chars | Metadata
Arbitrary values can be set in the metadata.
Since they do not affect GS2’s behavior, they can be used to store information used in the game. |
| password | string | | | | ~ 128 chars | Password required to access the room
When set, the password must be provided to retrieve or post messages. The password value cannot be referenced again after setting. Even game administrators cannot access messages without the password, as this may fall under communication privacy protections. |
| whiteListUserIds | List<string> | | | [] | 0 ~ 1000 items | List of user IDs with access to the room
When set, only the listed users can retrieve and post messages in the room. If empty, access is not restricted by user ID (though a password may still be required). |
| userId | string | | | | ~ 128 chars | Owner User ID
The user ID of the room owner. When set, only the owner can delete the room. Setting an owner is optional. |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Room](#room) | Rooms updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.UpdateRoomFromBackend(
&chat.UpdateRoomFromBackendRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
Metadata: pointy.String("ROOM_0001"),
Password: pointy.String("password-0003"),
WhiteListUserIds: []*string{
pointy.String("user-0001"),
pointy.String("user-0002"),
pointy.String("user-0003"),
},
UserId: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\UpdateRoomFromBackendRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->updateRoomFromBackend(
(new UpdateRoomFromBackendRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withMetadata("ROOM_0001")
->withPassword("password-0003")
->withWhiteListUserIds([
"user-0001",
"user-0002",
"user-0003",
])
->withUserId(null)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.UpdateRoomFromBackendRequest;
import io.gs2.chat.result.UpdateRoomFromBackendResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
UpdateRoomFromBackendResult result = client.updateRoomFromBackend(
new UpdateRoomFromBackendRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withMetadata("ROOM_0001")
.withPassword("password-0003")
.withWhiteListUserIds(Arrays.asList(
"user-0001",
"user-0002",
"user-0003"
))
.withUserId(null)
.withTimeOffsetToken(null)
);
Room item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateRoomFromBackend(
new Gs2.Gs2Chat.Request.UpdateRoomFromBackendRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithMetadata("ROOM_0001")
.WithPassword("password-0003")
.WithWhiteListUserIds(new string[] {
"user-0001",
"user-0002",
"user-0003",
})
.WithUserId(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.updateRoomFromBackend(
new Gs2Chat.UpdateRoomFromBackendRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withMetadata("ROOM_0001")
.withPassword("password-0003")
.withWhiteListUserIds([
"user-0001",
"user-0002",
"user-0003",
])
.withUserId(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.update_room_from_backend(
chat.UpdateRoomFromBackendRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_metadata('ROOM_0001')
.with_password('password-0003')
.with_white_list_user_ids([
'user-0001',
'user-0002',
'user-0003',
])
.with_user_id(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.update_room_from_backend({
namespaceName="namespace-0001",
roomName="room-0001",
metadata="ROOM_0001",
password="password-0003",
whiteListUserIds={
"user-0001",
"user-0002",
"user-0003"
},
userId=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.update_room_from_backend_async({
namespaceName="namespace-0001",
roomName="room-0001",
metadata="ROOM_0001",
password="password-0003",
whiteListUserIds={
"user-0001",
"user-0002",
"user-0003"
},
userId=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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteRoom
Delete Room
Deletes the specified room from the Namespace.
Only the room creator or a user listed in the whitelist can perform this operation.
An error is returned if the currently logged-in user does not have write permission on the room.
Deleting a room removes all messages and subscription information associated with it.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| accessToken | string | | ✓| | ~ 128 chars | Access token
The user ID of the room owner. When set, only the owner can delete the room. Setting an owner is optional. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Room](#room) | Room deleted |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DeleteRoom(
&chat.DeleteRoomRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
AccessToken: pointy.String("accessToken-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DeleteRoomRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->deleteRoom(
(new DeleteRoomRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withAccessToken("accessToken-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DeleteRoomRequest;
import io.gs2.chat.result.DeleteRoomResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DeleteRoomResult result = client.deleteRoom(
new DeleteRoomRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
);
Room item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteRoom(
new Gs2.Gs2Chat.Request.DeleteRoomRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithAccessToken("accessToken-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.deleteRoom(
new Gs2Chat.DeleteRoomRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.delete_room(
chat.DeleteRoomRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.delete_room({
namespaceName="namespace-0001",
roomName="room-0001",
accessToken="accessToken-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.delete_room_async({
namespaceName="namespace-0001",
roomName="room-0001",
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteRoomFromBackend
Delete Room from Backend
Deletes the specified room from the server side.
Unlike the player-facing delete API, this does not validate write permission against the access token, as it is intended for system-level operations.
Deleting a room removes all messages and subscription information associated with it.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| userId | string | | | | ~ 128 chars | Owner User ID
The user ID of the room owner. When set, only the owner can delete the room. Setting an owner is optional. |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Room](#room) | Room deleted |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DeleteRoomFromBackend(
&chat.DeleteRoomFromBackendRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
UserId: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DeleteRoomFromBackendRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->deleteRoomFromBackend(
(new DeleteRoomFromBackendRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withUserId(null)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DeleteRoomFromBackendRequest;
import io.gs2.chat.result.DeleteRoomFromBackendResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DeleteRoomFromBackendResult result = client.deleteRoomFromBackend(
new DeleteRoomFromBackendRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId(null)
.withTimeOffsetToken(null)
);
Room item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteRoomFromBackend(
new Gs2.Gs2Chat.Request.DeleteRoomFromBackendRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithUserId(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.deleteRoomFromBackend(
new Gs2Chat.DeleteRoomFromBackendRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.delete_room_from_backend(
chat.DeleteRoomFromBackendRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_user_id(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.delete_room_from_backend({
namespaceName="namespace-0001",
roomName="room-0001",
userId=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.delete_room_from_backend_async({
namespaceName="namespace-0001",
roomName="room-0001",
userId=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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeMessages
List Messages
Retrieves messages in the specified room, ordered chronologically from the specified start time to the current time.
You can optionally filter by category number to retrieve only specific types of messages (e.g., text messages, stamps).
If a password is set for the room, the correct password must be provided. If the room has a whitelist configured, access is restricted to listed users.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| password | string | | | | ~ 128 chars | Password required to access the room
When set, the password must be provided to retrieve or post messages. The password value cannot be referenced again after setting. Even game administrators cannot access messages without the password, as this may fall under communication privacy protections. |
| category | int | | | | 0 ~ 2147483645 | Category number for classifying messages |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
| startAt | long | | | Absolute time 1 hour before the current time | | Start time for message retrieval
Unix time, milliseconds |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Message>](#message) | List of Messages |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeMessages(
&chat.DescribeMessagesRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
Password: nil,
Category: nil,
AccessToken: pointy.String("accessToken-0001"),
StartAt: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeMessagesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeMessages(
(new DescribeMessagesRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withPassword(null)
->withCategory(null)
->withAccessToken("accessToken-0001")
->withStartAt(null)
->withLimit(null)
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeMessagesRequest;
import io.gs2.chat.result.DescribeMessagesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeMessagesResult result = client.describeMessages(
new DescribeMessagesRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withPassword(null)
.withCategory(null)
.withAccessToken("accessToken-0001")
.withStartAt(null)
.withLimit(null)
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeMessages(
new Gs2.Gs2Chat.Request.DescribeMessagesRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithPassword(null)
.WithCategory(null)
.WithAccessToken("accessToken-0001")
.WithStartAt(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeMessages(
new Gs2Chat.DescribeMessagesRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withPassword(null)
.withCategory(null)
.withAccessToken("accessToken-0001")
.withStartAt(null)
.withLimit(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_messages(
chat.DescribeMessagesRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_password(None)
.with_category(None)
.with_access_token('accessToken-0001')
.with_start_at(None)
.with_limit(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_messages({
namespaceName="namespace-0001",
roomName="room-0001",
password=nil,
category=nil,
accessToken="accessToken-0001",
startAt=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_messages_async({
namespaceName="namespace-0001",
roomName="room-0001",
password=nil,
category=nil,
accessToken="accessToken-0001",
startAt=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['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describeMessagesByUserId
List Messages by User ID
Retrieves messages in the specified room, ordered chronologically from the specified start time to the current time.
You can optionally filter by category number to retrieve only specific types of messages (e.g., text messages, stamps).
If a password is set for the room, the correct password must be provided. If the room has a whitelist configured, access is restricted to listed users.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| password | string | | | | ~ 128 chars | Password required to access the room
When set, the password must be provided to retrieve or post messages. The password value cannot be referenced again after setting. Even game administrators cannot access messages without the password, as this may fall under communication privacy protections. |
| category | int | | | | 0 ~ 2147483645 | Category number for classifying messages |
| userId | string | | ✓| | ~ 128 chars | User ID |
| startAt | long | | | Absolute time 1 hour before the current time | | Start time for message retrieval
Unix time, milliseconds |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Message>](#message) | List of Messages |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeMessagesByUserId(
&chat.DescribeMessagesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
Password: nil,
Category: nil,
UserId: pointy.String("user-0002"),
StartAt: nil,
Limit: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeMessagesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeMessagesByUserId(
(new DescribeMessagesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withPassword(null)
->withCategory(null)
->withUserId("user-0002")
->withStartAt(null)
->withLimit(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeMessagesByUserIdRequest;
import io.gs2.chat.result.DescribeMessagesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeMessagesByUserIdResult result = client.describeMessagesByUserId(
new DescribeMessagesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withPassword(null)
.withCategory(null)
.withUserId("user-0002")
.withStartAt(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeMessagesByUserId(
new Gs2.Gs2Chat.Request.DescribeMessagesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithPassword(null)
.WithCategory(null)
.WithUserId("user-0002")
.WithStartAt(null)
.WithLimit(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeMessagesByUserId(
new Gs2Chat.DescribeMessagesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withPassword(null)
.withCategory(null)
.withUserId("user-0002")
.withStartAt(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_messages_by_user_id(
chat.DescribeMessagesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_password(None)
.with_category(None)
.with_user_id('user-0002')
.with_start_at(None)
.with_limit(None)
.with_time_offset_token(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_messages_by_user_id({
namespaceName="namespace-0001",
roomName="room-0001",
password=nil,
category=nil,
userId="user-0002",
startAt=nil,
limit=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_messages_by_user_id_async({
namespaceName="namespace-0001",
roomName="room-0001",
password=nil,
category=nil,
userId="user-0002",
startAt=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['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describeLatestMessages
List latest Messages
Retrieves the newest messages in the specified room with pagination support, ordered from newest to oldest.
This is useful for displaying a chat timeline where the most recent messages are shown first.
You can optionally filter by category number to retrieve only specific types of messages.
If a password is set for the room, the correct password must be provided. If the room has a whitelist configured, access is restricted to listed users.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| password | string | | | | ~ 128 chars | Password required to access the room
When set, the password must be provided to retrieve or post messages. The password value cannot be referenced again after setting. Even game administrators cannot access messages without the password, as this may fall under communication privacy protections. |
| category | int | | | | 0 ~ 2147483645 | Category number for classifying messages |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Message>](#message) | List of Messages |
| nextPageToken | string | Page token to retrieve the rest of the listing |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeLatestMessages(
&chat.DescribeLatestMessagesRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
Password: nil,
Category: nil,
AccessToken: pointy.String("accessToken-0001"),
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeLatestMessagesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeLatestMessages(
(new DescribeLatestMessagesRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withPassword(null)
->withCategory(null)
->withAccessToken("accessToken-0001")
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeLatestMessagesRequest;
import io.gs2.chat.result.DescribeLatestMessagesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeLatestMessagesResult result = client.describeLatestMessages(
new DescribeLatestMessagesRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withPassword(null)
.withCategory(null)
.withAccessToken("accessToken-0001")
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeLatestMessages(
new Gs2.Gs2Chat.Request.DescribeLatestMessagesRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithPassword(null)
.WithCategory(null)
.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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeLatestMessages(
new Gs2Chat.DescribeLatestMessagesRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withPassword(null)
.withCategory(null)
.withAccessToken("accessToken-0001")
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_latest_messages(
chat.DescribeLatestMessagesRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_password(None)
.with_category(None)
.with_access_token('accessToken-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)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_latest_messages({
namespaceName="namespace-0001",
roomName="room-0001",
password=nil,
category=nil,
accessToken="accessToken-0001",
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_latest_messages_async({
namespaceName="namespace-0001",
roomName="room-0001",
password=nil,
category=nil,
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeLatestMessagesByUserId
List latest Messages by User ID
Retrieves the newest messages in the specified room with pagination support, ordered from newest to oldest.
This is useful for displaying a chat timeline where the most recent messages are shown first.
You can optionally filter by category number to retrieve only specific types of messages.
If a password is set for the room, the correct password must be provided. If the room has a whitelist configured, access is restricted to listed users.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| UUID | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| password | string | | | | ~ 128 chars | Password required to access the room
When set, the password must be provided to retrieve or post messages. The password value cannot be referenced again after setting. Even game administrators cannot access messages without the password, as this may fall under communication privacy protections. |
| category | int | | | | 0 ~ 2147483645 | Category number for classifying messages |
| 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 items to retrieve |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Message>](#message) | List of Messages |
| nextPageToken | string | Page token to retrieve the rest of the listing |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeLatestMessagesByUserId(
&chat.DescribeLatestMessagesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
Password: nil,
Category: nil,
UserId: pointy.String("user-0002"),
PageToken: nil,
Limit: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeLatestMessagesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeLatestMessagesByUserId(
(new DescribeLatestMessagesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withPassword(null)
->withCategory(null)
->withUserId("user-0002")
->withPageToken(null)
->withLimit(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeLatestMessagesByUserIdRequest;
import io.gs2.chat.result.DescribeLatestMessagesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeLatestMessagesByUserIdResult result = client.describeLatestMessagesByUserId(
new DescribeLatestMessagesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withPassword(null)
.withCategory(null)
.withUserId("user-0002")
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeLatestMessagesByUserId(
new Gs2.Gs2Chat.Request.DescribeLatestMessagesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithPassword(null)
.WithCategory(null)
.WithUserId("user-0002")
.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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeLatestMessagesByUserId(
new Gs2Chat.DescribeLatestMessagesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withPassword(null)
.withCategory(null)
.withUserId("user-0002")
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_latest_messages_by_user_id(
chat.DescribeLatestMessagesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_password(None)
.with_category(None)
.with_user_id('user-0002')
.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)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_latest_messages_by_user_id({
namespaceName="namespace-0001",
roomName="room-0001",
password=nil,
category=nil,
userId="user-0002",
pageToken=nil,
limit=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_latest_messages_by_user_id_async({
namespaceName="namespace-0001",
roomName="room-0001",
password=nil,
category=nil,
userId="user-0002",
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### post
Post a message
Posts a message to the specified room as the currently logged-in user.
You can specify a category number to classify the message type (e.g., 0 for text, 1 for stamp/sticker) and metadata containing the message content.
If the category has the rejectAccessTokenPost flag enabled in its Message Category Model, posting via access token is rejected and an error is returned. In that case, use the server-side PostByUserId API instead.
If a password is set for the room, the correct password must be provided. If the room has a whitelist, access is restricted to listed users.
After posting, notifications are automatically sent to all users subscribed to the room who match the message's category notification setting.
The message TTL is determined by the Namespace's messageLifeTimeDays setting.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
| category | int | | | 0 | 0 ~ 2147483645 | Category number for classifying messages
A numeric value used to classify messages. For example, 0 can represent text messages, 1 can represent stamps/stickers, and other values can represent custom message types. The category determines which CategoryModel rules apply to the message. |
| metadata | string | | ✓| | ~ 1024 chars | Metadata
Arbitrary values can be set in the metadata.
Since they do not affect GS2’s behavior, they can be used to store information used in the game. |
| password | string | | | | ~ 128 chars | Password |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Message](#message) | Posted message |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.Post(
&chat.PostRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
AccessToken: pointy.String("accessToken-0001"),
Category: nil,
Metadata: pointy.String("MESSAGE_0001"),
Password: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\PostRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->post(
(new PostRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withAccessToken("accessToken-0001")
->withCategory(null)
->withMetadata("MESSAGE_0001")
->withPassword(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.PostRequest;
import io.gs2.chat.result.PostResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
PostResult result = client.post(
new PostRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
.withCategory(null)
.withMetadata("MESSAGE_0001")
.withPassword(null)
);
Message item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.Post(
new Gs2.Gs2Chat.Request.PostRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithAccessToken("accessToken-0001")
.WithCategory(null)
.WithMetadata("MESSAGE_0001")
.WithPassword(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.post(
new Gs2Chat.PostRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
.withCategory(null)
.withMetadata("MESSAGE_0001")
.withPassword(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.post(
chat.PostRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_access_token('accessToken-0001')
.with_category(None)
.with_metadata('MESSAGE_0001')
.with_password(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.post({
namespaceName="namespace-0001",
roomName="room-0001",
accessToken="accessToken-0001",
category=nil,
metadata="MESSAGE_0001",
password=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.post_async({
namespaceName="namespace-0001",
roomName="room-0001",
accessToken="accessToken-0001",
category=nil,
metadata="MESSAGE_0001",
password=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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### postByUserId
Post Message by User ID
Posts a message to the specified room as the specified user from the server side.
Unlike the access-token-based post, this API is not subject to the rejectAccessTokenPost restriction on categories, making it suitable for posting system messages and announcements.
If a password is set for the room, the correct password must be provided. If the room has a whitelist, access is restricted to listed users.
After posting, notifications are automatically sent to all users subscribed to the room who match the message's category notification setting.
The message TTL is determined by the Namespace's messageLifeTimeDays setting.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| userId | string | | ✓| | ~ 128 chars | User ID |
| category | int | | | 0 | 0 ~ 2147483645 | Category number for classifying messages
A numeric value used to classify messages. For example, 0 can represent text messages, 1 can represent stamps/stickers, and other values can represent custom message types. The category determines which CategoryModel rules apply to the message. |
| metadata | string | | ✓| | ~ 1024 chars | Metadata
Arbitrary values can be set in the metadata.
Since they do not affect GS2’s behavior, they can be used to store information used in the game. |
| password | string | | | | ~ 128 chars | Password |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Message](#message) | Posted message |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.PostByUserId(
&chat.PostByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0002"),
UserId: pointy.String("user-0002"),
Category: nil,
Metadata: pointy.String("MESSAGE_0003"),
Password: pointy.String("password-0002"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\PostByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->postByUserId(
(new PostByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0002")
->withUserId("user-0002")
->withCategory(null)
->withMetadata("MESSAGE_0003")
->withPassword("password-0002")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.PostByUserIdRequest;
import io.gs2.chat.result.PostByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
PostByUserIdResult result = client.postByUserId(
new PostByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0002")
.withUserId("user-0002")
.withCategory(null)
.withMetadata("MESSAGE_0003")
.withPassword("password-0002")
.withTimeOffsetToken(null)
);
Message item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.PostByUserId(
new Gs2.Gs2Chat.Request.PostByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0002")
.WithUserId("user-0002")
.WithCategory(null)
.WithMetadata("MESSAGE_0003")
.WithPassword("password-0002")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.postByUserId(
new Gs2Chat.PostByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0002")
.withUserId("user-0002")
.withCategory(null)
.withMetadata("MESSAGE_0003")
.withPassword("password-0002")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.post_by_user_id(
chat.PostByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0002')
.with_user_id('user-0002')
.with_category(None)
.with_metadata('MESSAGE_0003')
.with_password('password-0002')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.post_by_user_id({
namespaceName="namespace-0001",
roomName="room-0002",
userId="user-0002",
category=nil,
metadata="MESSAGE_0003",
password="password-0002",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.post_by_user_id_async({
namespaceName="namespace-0001",
roomName="room-0002",
userId="user-0002",
category=nil,
metadata="MESSAGE_0003",
password="password-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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getMessage
Get Message
Retrieves a specific message by name from the specified room.
If a password is set for the room, the correct password must be provided. If the room has a whitelist, access is restricted to listed users.
The retrieved information includes the message category, metadata (content), the posting user ID, and the creation timestamp.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| messageName | string | | ✓| UUID | ~ 36 chars | Message name
Maintains a unique name for each message.
Names are automatically generated in UUID (Universally Unique Identifier) format and used to identify each message. |
| password | string | | | | ~ 128 chars | Password |
| accessToken | string | | | | ~ 128 chars | Access token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Message](#message) | Message |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetMessage(
&chat.GetMessageRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
MessageName: pointy.String("message-0001"),
Password: nil,
AccessToken: pointy.String("accessToken-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetMessageRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getMessage(
(new GetMessageRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withMessageName("message-0001")
->withPassword(null)
->withAccessToken("accessToken-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetMessageRequest;
import io.gs2.chat.result.GetMessageResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetMessageResult result = client.getMessage(
new GetMessageRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withMessageName("message-0001")
.withPassword(null)
.withAccessToken("accessToken-0001")
);
Message item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetMessage(
new Gs2.Gs2Chat.Request.GetMessageRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithMessageName("message-0001")
.WithPassword(null)
.WithAccessToken("accessToken-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getMessage(
new Gs2Chat.GetMessageRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withMessageName("message-0001")
.withPassword(null)
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_message(
chat.GetMessageRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_message_name('message-0001')
.with_password(None)
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_message({
namespaceName="namespace-0001",
roomName="room-0001",
messageName="message-0001",
password=nil,
accessToken="accessToken-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_message_async({
namespaceName="namespace-0001",
roomName="room-0001",
messageName="message-0001",
password=nil,
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getMessageByUserId
Get Message by User ID
Retrieves a specific message by name from the specified room using a server-side user ID.
If a password is set for the room, the correct password must be provided. If the room has a whitelist, access is restricted to listed users.
The retrieved information includes the message category, metadata (content), the posting user ID, and the creation timestamp.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| messageName | string | | ✓| UUID | ~ 36 chars | Message name
Maintains a unique name for each message.
Names are automatically generated in UUID (Universally Unique Identifier) format and used to identify each message. |
| password | string | | | | ~ 128 chars | Password |
| userId | string | | | | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Message](#message) | Message |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetMessageByUserId(
&chat.GetMessageByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
MessageName: pointy.String("message-0001"),
Password: nil,
UserId: pointy.String("user-0002"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetMessageByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getMessageByUserId(
(new GetMessageByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withMessageName("message-0001")
->withPassword(null)
->withUserId("user-0002")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetMessageByUserIdRequest;
import io.gs2.chat.result.GetMessageByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetMessageByUserIdResult result = client.getMessageByUserId(
new GetMessageByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withMessageName("message-0001")
.withPassword(null)
.withUserId("user-0002")
.withTimeOffsetToken(null)
);
Message item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetMessageByUserId(
new Gs2.Gs2Chat.Request.GetMessageByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithMessageName("message-0001")
.WithPassword(null)
.WithUserId("user-0002")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getMessageByUserId(
new Gs2Chat.GetMessageByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withMessageName("message-0001")
.withPassword(null)
.withUserId("user-0002")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_message_by_user_id(
chat.GetMessageByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_message_name('message-0001')
.with_password(None)
.with_user_id('user-0002')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_message_by_user_id({
namespaceName="namespace-0001",
roomName="room-0001",
messageName="message-0001",
password=nil,
userId="user-0002",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_message_by_user_id_async({
namespaceName="namespace-0001",
roomName="room-0001",
messageName="message-0001",
password=nil,
userId="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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteMessage
Delete message
Deletes a specific message from the specified room.
This operation permanently removes the message and it cannot be recovered.
This is a management API that can delete any message regardless of the posting user.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name
Unique Room name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| userId | string | | | | ~ 128 chars | User ID |
| messageName | string | | ✓| UUID | ~ 36 chars | Message name
Maintains a unique name for each message.
Names are automatically generated in UUID (Universally Unique Identifier) format and used to identify each message. |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Message](#message) | Message deleted |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DeleteMessage(
&chat.DeleteMessageRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
UserId: pointy.String("user-0001"),
MessageName: pointy.String("message-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DeleteMessageRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->deleteMessage(
(new DeleteMessageRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withUserId("user-0001")
->withMessageName("message-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DeleteMessageRequest;
import io.gs2.chat.result.DeleteMessageResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DeleteMessageResult result = client.deleteMessage(
new DeleteMessageRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId("user-0001")
.withMessageName("message-0001")
.withTimeOffsetToken(null)
);
Message item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteMessage(
new Gs2.Gs2Chat.Request.DeleteMessageRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithUserId("user-0001")
.WithMessageName("message-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.deleteMessage(
new Gs2Chat.DeleteMessageRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId("user-0001")
.withMessageName("message-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.delete_message(
chat.DeleteMessageRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_user_id('user-0001')
.with_message_name('message-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.delete_message({
namespaceName="namespace-0001",
roomName="room-0001",
userId="user-0001",
messageName="message-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.delete_message_async({
namespaceName="namespace-0001",
roomName="room-0001",
userId="user-0001",
messageName="message-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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeSubscribes
List Room Subscriptions
You can get a list of subscriptions by specifying a page token and a limit on the number of acquisitions.
This allows you to check an overview of the rooms that the user is subscribed to.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomNamePrefix | string | | | | ~ 64 chars | Filter by Room name prefix |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Subscribe>](#subscribe) | List of Room Subscriptions |
| nextPageToken | string | Page token to retrieve the rest of the listing |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeSubscribes(
&chat.DescribeSubscribesRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomNamePrefix: nil,
AccessToken: pointy.String("accessToken-0001"),
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeSubscribesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeSubscribes(
(new DescribeSubscribesRequest())
->withNamespaceName("namespace-0001")
->withRoomNamePrefix(null)
->withAccessToken("accessToken-0001")
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeSubscribesRequest;
import io.gs2.chat.result.DescribeSubscribesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeSubscribesResult result = client.describeSubscribes(
new DescribeSubscribesRequest()
.withNamespaceName("namespace-0001")
.withRoomNamePrefix(null)
.withAccessToken("accessToken-0001")
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribes(
new Gs2.Gs2Chat.Request.DescribeSubscribesRequest()
.WithNamespaceName("namespace-0001")
.WithRoomNamePrefix(null)
.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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeSubscribes(
new Gs2Chat.DescribeSubscribesRequest()
.withNamespaceName("namespace-0001")
.withRoomNamePrefix(null)
.withAccessToken("accessToken-0001")
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_subscribes(
chat.DescribeSubscribesRequest()
.with_namespace_name('namespace-0001')
.with_room_name_prefix(None)
.with_access_token('accessToken-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)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_subscribes({
namespaceName="namespace-0001",
roomNamePrefix=nil,
accessToken="accessToken-0001",
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_subscribes_async({
namespaceName="namespace-0001",
roomNamePrefix=nil,
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeSubscribesByUserId
List Room Subscriptions by User ID
You can get a list of subscriptions by specifying a page token and a limit on the number of acquisitions.
This allows you to check an overview of the rooms that the user is subscribed to.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomNamePrefix | string | | | | ~ 64 chars | Filter by Room name prefix |
| 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 items to retrieve |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Subscribe>](#subscribe) | List of Room Subscriptions |
| nextPageToken | string | Page token to retrieve the rest of the listing |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeSubscribesByUserId(
&chat.DescribeSubscribesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomNamePrefix: nil,
UserId: pointy.String("user-0001"),
PageToken: nil,
Limit: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeSubscribesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeSubscribesByUserId(
(new DescribeSubscribesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRoomNamePrefix(null)
->withUserId("user-0001")
->withPageToken(null)
->withLimit(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeSubscribesByUserIdRequest;
import io.gs2.chat.result.DescribeSubscribesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeSubscribesByUserIdResult result = client.describeSubscribesByUserId(
new DescribeSubscribesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomNamePrefix(null)
.withUserId("user-0001")
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribesByUserId(
new Gs2.Gs2Chat.Request.DescribeSubscribesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRoomNamePrefix(null)
.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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeSubscribesByUserId(
new Gs2Chat.DescribeSubscribesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomNamePrefix(null)
.withUserId("user-0001")
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_subscribes_by_user_id(
chat.DescribeSubscribesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_room_name_prefix(None)
.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)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_subscribes_by_user_id({
namespaceName="namespace-0001",
roomNamePrefix=nil,
userId="user-0001",
pageToken=nil,
limit=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_subscribes_by_user_id_async({
namespaceName="namespace-0001",
roomNamePrefix=nil,
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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeSubscribesByRoomName
List users subscribed to a room by specifying Room name
You can get a list of users subscribed to a room by specifying a page token and a limit on the number of acquisitions.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name to subscribe to
The name of the chat room to subscribe to. When subscribed, push notifications are sent via GS2-Gateway whenever new messages are posted to this room. |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Subscribe>](#subscribe) | List of Room Subscriptions |
| nextPageToken | string | Page token to retrieve the rest of the listing |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeSubscribesByRoomName(
&chat.DescribeSubscribesByRoomNameRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeSubscribesByRoomNameRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeSubscribesByRoomName(
(new DescribeSubscribesByRoomNameRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeSubscribesByRoomNameRequest;
import io.gs2.chat.result.DescribeSubscribesByRoomNameResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeSubscribesByRoomNameResult result = client.describeSubscribesByRoomName(
new DescribeSubscribesByRoomNameRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribesByRoomName(
new Gs2.Gs2Chat.Request.DescribeSubscribesByRoomNameRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeSubscribesByRoomName(
new Gs2Chat.DescribeSubscribesByRoomNameRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_subscribes_by_room_name(
chat.DescribeSubscribesByRoomNameRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-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)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_subscribes_by_room_name({
namespaceName="namespace-0001",
roomName="room-0001",
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_subscribes_by_room_name_async({
namespaceName="namespace-0001",
roomName="room-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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### subscribe
Subscribe to a room
Subscribes the currently logged-in user to receive notifications when new messages are posted to the specified room.
You can configure notification preferences by specifying notification types, which allow filtering notifications by message category.
When a message is posted to the subscribed room, notifications are distributed to all subscribers whose category filters match.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name to subscribe to
The name of the chat room to subscribe to. When subscribed, push notifications are sent via GS2-Gateway whenever new messages are posted to this room. |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
| notificationTypes | [List<NotificationType>](#notificationtype) | | | [] | 0 ~ 100 items | List of categories to receive notifications of new messages
Filters which message categories trigger push notifications. If empty, notifications are sent for all categories. Each entry specifies a category number and optional mobile push notification forwarding. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Subscribe](#subscribe) | Room Subscription |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.Subscribe(
&chat.SubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
AccessToken: pointy.String("accessToken-0001"),
NotificationTypes: []chat.NotificationType{
chat.NotificationType{
},
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\SubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->subscribe(
(new SubscribeRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withAccessToken("accessToken-0001")
->withNotificationTypes([
(new \Gs2\Chat\Model\NotificationType()),
])
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.SubscribeRequest;
import io.gs2.chat.result.SubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
SubscribeResult result = client.subscribe(
new SubscribeRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
.withNotificationTypes(Arrays.asList(
new io.gs2.chat.model.NotificationType()
))
);
Subscribe item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.Subscribe(
new Gs2.Gs2Chat.Request.SubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithAccessToken("accessToken-0001")
.WithNotificationTypes(new Gs2.Gs2Chat.Model.NotificationType[] {
new Gs2.Gs2Chat.Model.NotificationType(),
}),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.subscribe(
new Gs2Chat.SubscribeRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
.withNotificationTypes([
new Gs2Chat.model.NotificationType(),
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.subscribe(
chat.SubscribeRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_access_token('accessToken-0001')
.with_notification_types([
chat.NotificationType(),
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.subscribe({
namespaceName="namespace-0001",
roomName="room-0001",
accessToken="accessToken-0001",
notificationTypes={
{
}
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.subscribe_async({
namespaceName="namespace-0001",
roomName="room-0001",
accessToken="accessToken-0001",
notificationTypes={
{
}
},
})
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### subscribeByUserId
Subscribe to a room by User ID
Subscribes the specified user to receive notifications when new messages are posted to the specified room.
You can configure notification preferences by specifying notification types, which allow filtering notifications by message category.
When a message is posted to the subscribed room, notifications are distributed to all subscribers whose category filters match.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name to subscribe to
The name of the chat room to subscribe to. When subscribed, push notifications are sent via GS2-Gateway whenever new messages are posted to this room. |
| userId | string | | ✓| | ~ 128 chars | User ID |
| notificationTypes | [List<NotificationType>](#notificationtype) | | | [] | 0 ~ 100 items | List of categories to receive notifications of new messages
Filters which message categories trigger push notifications. If empty, notifications are sent for all categories. Each entry specifies a category number and optional mobile push notification forwarding. |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Subscribe](#subscribe) | Room Subscription |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.SubscribeByUserId(
&chat.SubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
UserId: pointy.String("user-0001"),
NotificationTypes: []chat.NotificationType{
*.NotificationType(),
},
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\SubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->subscribeByUserId(
(new SubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withUserId("user-0001")
->withNotificationTypes([
NotificationType(),
])
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.SubscribeByUserIdRequest;
import io.gs2.chat.result.SubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
SubscribeByUserIdResult result = client.subscribeByUserId(
new SubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId("user-0001")
.withNotificationTypes(Arrays.asList(
new NotificationType()
))
.withTimeOffsetToken(null)
);
Subscribe item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.SubscribeByUserId(
new Gs2.Gs2Chat.Request.SubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithUserId("user-0001")
.WithNotificationTypes(new Gs2.Gs2Chat.Model.NotificationType[] {
new Gs2.Gs2Chat.Model.NotificationType(),
})
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.subscribeByUserId(
new Gs2Chat.SubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId("user-0001")
.withNotificationTypes([
new NotificationType(),
])
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.subscribe_by_user_id(
chat.SubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_user_id('user-0001')
.with_notification_types([
NotificationType(),
])
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.subscribe_by_user_id({
namespaceName="namespace-0001",
roomName="room-0001",
userId="user-0001",
notificationTypes={
{}
},
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.subscribe_by_user_id_async({
namespaceName="namespace-0001",
roomName="room-0001",
userId="user-0001",
notificationTypes={
{}
},
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getSubscribe
Get Room Subscription
Retrieves the subscription information for the currently logged-in user to the specified room.
The returned information includes the configured notification type preferences for this subscription.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name to subscribe to
The name of the chat room to subscribe to. When subscribed, push notifications are sent via GS2-Gateway whenever new messages are posted to this room. |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Subscribe](#subscribe) | Room Subscription |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetSubscribe(
&chat.GetSubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
AccessToken: pointy.String("accessToken-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetSubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getSubscribe(
(new GetSubscribeRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withAccessToken("accessToken-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetSubscribeRequest;
import io.gs2.chat.result.GetSubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetSubscribeResult result = client.getSubscribe(
new GetSubscribeRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
);
Subscribe item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribe(
new Gs2.Gs2Chat.Request.GetSubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithAccessToken("accessToken-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getSubscribe(
new Gs2Chat.GetSubscribeRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_subscribe(
chat.GetSubscribeRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_subscribe({
namespaceName="namespace-0001",
roomName="room-0001",
accessToken="accessToken-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_subscribe_async({
namespaceName="namespace-0001",
roomName="room-0001",
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getSubscribeByUserId
Get Room Subscription by User ID
Retrieves the subscription information for the specified user to the specified room.
The returned information includes the configured notification type preferences for this subscription.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name to subscribe to
The name of the chat room to subscribe to. When subscribed, push notifications are sent via GS2-Gateway whenever new messages are posted to this room. |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Subscribe](#subscribe) | Room Subscription |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetSubscribeByUserId(
&chat.GetSubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetSubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getSubscribeByUserId(
(new GetSubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetSubscribeByUserIdRequest;
import io.gs2.chat.result.GetSubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetSubscribeByUserIdResult result = client.getSubscribeByUserId(
new GetSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
Subscribe item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribeByUserId(
new Gs2.Gs2Chat.Request.GetSubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getSubscribeByUserId(
new Gs2Chat.GetSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_subscribe_by_user_id(
chat.GetSubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_user_id('user-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_subscribe_by_user_id({
namespaceName="namespace-0001",
roomName="room-0001",
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_subscribe_by_user_id_async({
namespaceName="namespace-0001",
roomName="room-0001",
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateNotificationType
Update notification methods
Updates the notification type preferences for the currently logged-in user's subscription to the specified room.
By configuring notification types, you can control which message categories trigger push notifications for the user.
For example, you can set the subscription to only receive notifications for certain category numbers, or disable notifications for specific categories.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Subscribed room name
The name of the subscribed chat room whose notification settings will be updated. |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
| notificationTypes | [List<NotificationType>](#notificationtype) | | | [] | 0 ~ 100 items | List of categories to receive notifications of new messages
Filters which message categories trigger push notifications. If empty, notifications are sent for all categories. Each entry specifies a category number and optional mobile push notification forwarding. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Subscribe](#subscribe) | Updated Subscription |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.UpdateNotificationType(
&chat.UpdateNotificationTypeRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
AccessToken: pointy.String("accessToken-0001"),
NotificationTypes: []chat.NotificationType{
*.NotificationType(),
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\UpdateNotificationTypeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->updateNotificationType(
(new UpdateNotificationTypeRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withAccessToken("accessToken-0001")
->withNotificationTypes([
NotificationType(),
])
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.UpdateNotificationTypeRequest;
import io.gs2.chat.result.UpdateNotificationTypeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
UpdateNotificationTypeResult result = client.updateNotificationType(
new UpdateNotificationTypeRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
.withNotificationTypes(Arrays.asList(
new NotificationType()
))
);
Subscribe item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNotificationType(
new Gs2.Gs2Chat.Request.UpdateNotificationTypeRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithAccessToken("accessToken-0001")
.WithNotificationTypes(new Gs2.Gs2Chat.Model.NotificationType[] {
new Gs2.Gs2Chat.Model.NotificationType(),
}),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.updateNotificationType(
new Gs2Chat.UpdateNotificationTypeRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
.withNotificationTypes([
new NotificationType(),
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.update_notification_type(
chat.UpdateNotificationTypeRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_access_token('accessToken-0001')
.with_notification_types([
NotificationType(),
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.update_notification_type({
namespaceName="namespace-0001",
roomName="room-0001",
accessToken="accessToken-0001",
notificationTypes={
{}
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.update_notification_type_async({
namespaceName="namespace-0001",
roomName="room-0001",
accessToken="accessToken-0001",
notificationTypes={
{}
},
})
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateNotificationTypeByUserId
Update notification methods by User ID
Updates the notification type preferences for the specified user's subscription to the specified room.
By configuring notification types, you can control which message categories trigger push notifications for the user.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Subscribed room name
The name of the subscribed chat room whose notification settings will be updated. |
| userId | string | | ✓| | ~ 128 chars | User ID |
| notificationTypes | [List<NotificationType>](#notificationtype) | | | [] | 0 ~ 100 items | List of categories to receive notifications of new messages
Filters which message categories trigger push notifications. If empty, notifications are sent for all categories. Each entry specifies a category number and optional mobile push notification forwarding. |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Subscribe](#subscribe) | Updated Subscription |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.UpdateNotificationTypeByUserId(
&chat.UpdateNotificationTypeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
UserId: pointy.String("user-0001"),
NotificationTypes: []chat.NotificationType{
*.NotificationType(),
},
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\UpdateNotificationTypeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->updateNotificationTypeByUserId(
(new UpdateNotificationTypeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withUserId("user-0001")
->withNotificationTypes([
NotificationType(),
])
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.UpdateNotificationTypeByUserIdRequest;
import io.gs2.chat.result.UpdateNotificationTypeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
UpdateNotificationTypeByUserIdResult result = client.updateNotificationTypeByUserId(
new UpdateNotificationTypeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId("user-0001")
.withNotificationTypes(Arrays.asList(
new NotificationType()
))
.withTimeOffsetToken(null)
);
Subscribe item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNotificationTypeByUserId(
new Gs2.Gs2Chat.Request.UpdateNotificationTypeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithUserId("user-0001")
.WithNotificationTypes(new Gs2.Gs2Chat.Model.NotificationType[] {
new Gs2.Gs2Chat.Model.NotificationType(),
})
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.updateNotificationTypeByUserId(
new Gs2Chat.UpdateNotificationTypeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId("user-0001")
.withNotificationTypes([
new NotificationType(),
])
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.update_notification_type_by_user_id(
chat.UpdateNotificationTypeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_user_id('user-0001')
.with_notification_types([
NotificationType(),
])
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.update_notification_type_by_user_id({
namespaceName="namespace-0001",
roomName="room-0001",
userId="user-0001",
notificationTypes={
{}
},
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.update_notification_type_by_user_id_async({
namespaceName="namespace-0001",
roomName="room-0001",
userId="user-0001",
notificationTypes={
{}
},
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### unsubscribe
Unsubscribe from a room
Removes the currently logged-in user's subscription to the specified room.
After unsubscribing, the user will no longer receive notifications when new messages are posted to this room.
The subscription record is permanently deleted.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name to unsubscribe from
The name of the chat room to unsubscribe from. |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Subscribe](#subscribe) | Unsubscribed room |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.Unsubscribe(
&chat.UnsubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
AccessToken: pointy.String("accessToken-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\UnsubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->unsubscribe(
(new UnsubscribeRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withAccessToken("accessToken-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.UnsubscribeRequest;
import io.gs2.chat.result.UnsubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
UnsubscribeResult result = client.unsubscribe(
new UnsubscribeRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
);
Subscribe item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.Unsubscribe(
new Gs2.Gs2Chat.Request.UnsubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithAccessToken("accessToken-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.unsubscribe(
new Gs2Chat.UnsubscribeRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.unsubscribe(
chat.UnsubscribeRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.unsubscribe({
namespaceName="namespace-0001",
roomName="room-0001",
accessToken="accessToken-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.unsubscribe_async({
namespaceName="namespace-0001",
roomName="room-0001",
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### unsubscribeByUserId
Unsubscribe from a subscription by User ID
Removes the specified user's subscription to the specified room.
After unsubscribing, the user will no longer receive notifications when new messages are posted to this room.
The subscription record is permanently deleted.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| roomName | string | | ✓| | ~ 128 chars | Room name to unsubscribe from
The name of the chat room to unsubscribe from. |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Subscribe](#subscribe) | Unsubscribed room |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.UnsubscribeByUserId(
&chat.UnsubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RoomName: pointy.String("room-0001"),
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\UnsubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->unsubscribeByUserId(
(new UnsubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRoomName("room-0001")
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.UnsubscribeByUserIdRequest;
import io.gs2.chat.result.UnsubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
UnsubscribeByUserIdResult result = client.unsubscribeByUserId(
new UnsubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
Subscribe item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.UnsubscribeByUserId(
new Gs2.Gs2Chat.Request.UnsubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRoomName("room-0001")
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.unsubscribeByUserId(
new Gs2Chat.UnsubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRoomName("room-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.unsubscribe_by_user_id(
chat.UnsubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_room_name('room-0001')
.with_user_id('user-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.unsubscribe_by_user_id({
namespaceName="namespace-0001",
roomName="room-0001",
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.unsubscribe_by_user_id_async({
namespaceName="namespace-0001",
roomName="room-0001",
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeCategoryModels
List Message Category Models
Retrieves all currently active Message Category Models in the specified Namespace.
Message Category Models define message categories (e.g., normal text messages, stamps/stickers) and control posting permissions per category.
Unlike the master variant, this returns only the activated (published) models without pagination.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<CategoryModel>](#categorymodel) | List of Message Category Models |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeCategoryModels(
&chat.DescribeCategoryModelsRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeCategoryModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeCategoryModels(
(new DescribeCategoryModelsRequest())
->withNamespaceName("namespace-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeCategoryModelsRequest;
import io.gs2.chat.result.DescribeCategoryModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeCategoryModelsResult result = client.describeCategoryModels(
new DescribeCategoryModelsRequest()
.withNamespaceName("namespace-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCategoryModels(
new Gs2.Gs2Chat.Request.DescribeCategoryModelsRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeCategoryModels(
new Gs2Chat.DescribeCategoryModelsRequest()
.withNamespaceName("namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_category_models(
chat.DescribeCategoryModelsRequest()
.with_namespace_name('namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_category_models({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_category_models_async({
namespaceName="namespace-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['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### getCategoryModel
Get Message Category Model
Retrieves the currently active Message Category Model with the specified category number in the specified Namespace.
The retrieved information includes whether access-token-authenticated users are restricted from posting to this category (rejectAccessTokenPost flag).
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| category | int | | ✓| | 0 ~ 2147483645 | Category
A numeric identifier for the message category. Messages posted with this category number will follow the rules defined in this model, such as whether player posts are allowed or rejected. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CategoryModel](#categorymodel) | Message Category Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetCategoryModel(
&chat.GetCategoryModelRequest {
NamespaceName: pointy.String("namespace-0001"),
Category: pointy.Int32(0),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetCategoryModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getCategoryModel(
(new GetCategoryModelRequest())
->withNamespaceName("namespace-0001")
->withCategory(0)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetCategoryModelRequest;
import io.gs2.chat.result.GetCategoryModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetCategoryModelResult result = client.getCategoryModel(
new GetCategoryModelRequest()
.withNamespaceName("namespace-0001")
.withCategory(0)
);
CategoryModel item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCategoryModel(
new Gs2.Gs2Chat.Request.GetCategoryModelRequest()
.WithNamespaceName("namespace-0001")
.WithCategory(0),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getCategoryModel(
new Gs2Chat.GetCategoryModelRequest()
.withNamespaceName("namespace-0001")
.withCategory(0)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_category_model(
chat.GetCategoryModelRequest()
.with_namespace_name('namespace-0001')
.with_category(0)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_category_model({
namespaceName="namespace-0001",
category=0,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_category_model_async({
namespaceName="namespace-0001",
category=0,
})
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### exportMaster
Export Message Category Model Master in a master data format that can be activated
Exports the current Message Category Model Master data in a format that can be used for activation.
The exported data can be used to back up the current master configuration, or to import it into another Namespace.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CurrentModelMaster](#currentmodelmaster) | Message Category Model master data that can be activated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.ExportMaster(
&chat.ExportMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\ExportMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->exportMaster(
(new ExportMasterRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.ExportMasterRequest;
import io.gs2.chat.result.ExportMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
ExportMasterResult result = client.exportMaster(
new ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExportMaster(
new Gs2.Gs2Chat.Request.ExportMasterRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.exportMaster(
new Gs2Chat.ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.export_master(
chat.ExportMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.export_master({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.export_master_async({
namespaceName="namespace-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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getCurrentModelMaster
Get currently active Message Category Model master data
Retrieves the master data of the Message Category Models that are currently active (published) in the specified Namespace.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CurrentModelMaster](#currentmodelmaster) | Currently active Message Category Model master data |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetCurrentModelMaster(
&chat.GetCurrentModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetCurrentModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getCurrentModelMaster(
(new GetCurrentModelMasterRequest())
->withNamespaceName("namespace-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetCurrentModelMasterRequest;
import io.gs2.chat.result.GetCurrentModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetCurrentModelMasterResult result = client.getCurrentModelMaster(
new GetCurrentModelMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCurrentModelMaster(
new Gs2.Gs2Chat.Request.GetCurrentModelMasterRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getCurrentModelMaster(
new Gs2Chat.GetCurrentModelMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_current_model_master(
chat.GetCurrentModelMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_current_model_master({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_current_model_master_async({
namespaceName="namespace-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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### preUpdateCurrentModelMaster
Update currently active Message Category Model master data (3-phase version)
When uploading master data larger than 1MB, the update is performed in 3 phases.
1. Execute this API to obtain a token and URL for uploading.
2. Upload the master data to the obtained URL.
3. Execute UpdateCurrentModelMaster by passing the token obtained from the upload to reflect the master data.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| uploadToken | string | Token used to reflect results after upload |
| uploadUrl | string | URL used to upload |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.PreUpdateCurrentModelMaster(
&chat.PreUpdateCurrentModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
uploadToken := result.UploadToken
uploadUrl := result.UploadUrl
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\PreUpdateCurrentModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->preUpdateCurrentModelMaster(
(new PreUpdateCurrentModelMasterRequest())
->withNamespaceName("namespace-0001")
);
$uploadToken = $result->getUploadToken();
$uploadUrl = $result->getUploadUrl();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.PreUpdateCurrentModelMasterRequest;
import io.gs2.chat.result.PreUpdateCurrentModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
PreUpdateCurrentModelMasterResult result = client.preUpdateCurrentModelMaster(
new PreUpdateCurrentModelMasterRequest()
.withNamespaceName("namespace-0001")
);
String uploadToken = result.getUploadToken();
String uploadUrl = result.getUploadUrl();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.PreUpdateCurrentModelMaster(
new Gs2.Gs2Chat.Request.PreUpdateCurrentModelMasterRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var uploadToken = result.UploadToken;
var uploadUrl = result.UploadUrl;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.preUpdateCurrentModelMaster(
new Gs2Chat.PreUpdateCurrentModelMasterRequest()
.withNamespaceName("namespace-0001")
);
const uploadToken = result.getUploadToken();
const uploadUrl = result.getUploadUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.pre_update_current_model_master(
chat.PreUpdateCurrentModelMasterRequest()
.with_namespace_name('namespace-0001')
)
upload_token = result.upload_token
upload_url = result.upload_url
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.pre_update_current_model_master({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.pre_update_current_model_master_async({
namespaceName="namespace-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['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
---
### updateCurrentModelMaster
Update currently active Message Category Model master data
Updates and activates (publishes) the master data of the Message Category Models in the specified Namespace.
Supports two modes: 'direct' mode for inline master data, and 'preUpload' mode for master data that was uploaded in advance.
For master data larger than 1MB, use the 3-phase update flow: PreUpdate -> Upload -> Update (preUpload mode).
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| mode | string (enum)
enum {
"direct",
"preUpload"
}
| | | "direct" | | Update mode"direct": Directly update master data / "preUpload": Upload master data and then update / |
| settings | string | {mode} == "direct" | ✓*| | ~ 5242880 bytes (5MB) | Master data
* Required if mode is "direct" |
| uploadToken | string | {mode} == "preUpload" | ✓*| | ~ 1024 chars | Token obtained by pre-upload
Used to apply the uploaded master data.
* Required if mode is "preUpload" |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CurrentModelMaster](#currentmodelmaster) | Updated master data of the currently active Message Category Models |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.UpdateCurrentModelMaster(
&chat.UpdateCurrentModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Mode: pointy.String("direct"),
Settings: pointy.String("{\"version\": \"2020-04-30\", \"categoryModels\": [{\"category\": 0, \"rejectAccessTokenPost\": \"Disabled\"}, {\"category\": 1, \"rejectAccessTokenPost\": \"Disabled\"}]}"),
UploadToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\UpdateCurrentModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->updateCurrentModelMaster(
(new UpdateCurrentModelMasterRequest())
->withNamespaceName("namespace-0001")
->withMode("direct")
->withSettings("{\"version\": \"2020-04-30\", \"categoryModels\": [{\"category\": 0, \"rejectAccessTokenPost\": \"Disabled\"}, {\"category\": 1, \"rejectAccessTokenPost\": \"Disabled\"}]}")
->withUploadToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.UpdateCurrentModelMasterRequest;
import io.gs2.chat.result.UpdateCurrentModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
UpdateCurrentModelMasterResult result = client.updateCurrentModelMaster(
new UpdateCurrentModelMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\"version\": \"2020-04-30\", \"categoryModels\": [{\"category\": 0, \"rejectAccessTokenPost\": \"Disabled\"}, {\"category\": 1, \"rejectAccessTokenPost\": \"Disabled\"}]}")
.withUploadToken(null)
);
CurrentModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentModelMaster(
new Gs2.Gs2Chat.Request.UpdateCurrentModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMode("direct")
.WithSettings("{\"version\": \"2020-04-30\", \"categoryModels\": [{\"category\": 0, \"rejectAccessTokenPost\": \"Disabled\"}, {\"category\": 1, \"rejectAccessTokenPost\": \"Disabled\"}]}")
.WithUploadToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.updateCurrentModelMaster(
new Gs2Chat.UpdateCurrentModelMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\"version\": \"2020-04-30\", \"categoryModels\": [{\"category\": 0, \"rejectAccessTokenPost\": \"Disabled\"}, {\"category\": 1, \"rejectAccessTokenPost\": \"Disabled\"}]}")
.withUploadToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.update_current_model_master(
chat.UpdateCurrentModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_mode('direct')
.with_settings('{"version": "2020-04-30", "categoryModels": [{"category": 0, "rejectAccessTokenPost": "Disabled"}, {"category": 1, "rejectAccessTokenPost": "Disabled"}]}')
.with_upload_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.update_current_model_master({
namespaceName="namespace-0001",
mode="direct",
settings="{\"version\": \"2020-04-30\", \"categoryModels\": [{\"category\": 0, \"rejectAccessTokenPost\": \"Disabled\"}, {\"category\": 1, \"rejectAccessTokenPost\": \"Disabled\"}]}",
uploadToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.update_current_model_master_async({
namespaceName="namespace-0001",
mode="direct",
settings="{\"version\": \"2020-04-30\", \"categoryModels\": [{\"category\": 0, \"rejectAccessTokenPost\": \"Disabled\"}, {\"category\": 1, \"rejectAccessTokenPost\": \"Disabled\"}]}",
uploadToken=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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateCurrentModelMasterFromGitHub
Update currently active Message Category Model master data from GitHub
Updates and activates (publishes) the master data by fetching it directly from a GitHub repository.
The checkout settings specify the repository, branch/tag, and file path to use.
This is useful for managing master data in version control and deploying it directly.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| checkoutSetting | [GitHubCheckoutSetting](#githubcheckoutsetting) | | ✓| | | Setting for checking out master data from GitHub |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CurrentModelMaster](#currentmodelmaster) | Updated master data of the currently active Message Category Models |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.UpdateCurrentModelMasterFromGitHub(
&chat.UpdateCurrentModelMasterFromGitHubRequest {
NamespaceName: pointy.String("namespace-0001"),
CheckoutSetting: &chat.GitHubCheckoutSetting{
ApiKeyId: pointy.String("apiKeyId-0001"),
RepositoryName: pointy.String("gs2io/master-data"),
SourcePath: pointy.String("path/to/file.json"),
ReferenceType: pointy.String("branch"),
BranchName: pointy.String("develop"),
},
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\UpdateCurrentModelMasterFromGitHubRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->updateCurrentModelMasterFromGitHub(
(new UpdateCurrentModelMasterFromGitHubRequest())
->withNamespaceName("namespace-0001")
->withCheckoutSetting((new GitHubCheckoutSetting())
->withApiKeyId("apiKeyId-0001")
->withRepositoryName("gs2io/master-data")
->withSourcePath("path/to/file.json")
->withReferenceType("branch")
->withBranchName("develop")
)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.UpdateCurrentModelMasterFromGitHubRequest;
import io.gs2.chat.result.UpdateCurrentModelMasterFromGitHubResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
UpdateCurrentModelMasterFromGitHubResult result = client.updateCurrentModelMasterFromGitHub(
new UpdateCurrentModelMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
CurrentModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentModelMasterFromGitHub(
new Gs2.Gs2Chat.Request.UpdateCurrentModelMasterFromGitHubRequest()
.WithNamespaceName("namespace-0001")
.WithCheckoutSetting(new Gs2.Gs2Chat.Model.GitHubCheckoutSetting()
.WithApiKeyId("apiKeyId-0001")
.WithRepositoryName("gs2io/master-data")
.WithSourcePath("path/to/file.json")
.WithReferenceType("branch")
.WithBranchName("develop")
),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.updateCurrentModelMasterFromGitHub(
new Gs2Chat.UpdateCurrentModelMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new Gs2Chat.model.GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.update_current_model_master_from_git_hub(
chat.UpdateCurrentModelMasterFromGitHubRequest()
.with_namespace_name('namespace-0001')
.with_checkout_setting(chat.GitHubCheckoutSetting()
.with_api_key_id('apiKeyId-0001')
.with_repository_name('gs2io/master-data')
.with_source_path('path/to/file.json')
.with_reference_type('branch')
.with_branch_name('develop')
)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.update_current_model_master_from_git_hub({
namespaceName="namespace-0001",
checkoutSetting={
api_key_id="apiKeyId-0001",
repository_name="gs2io/master-data",
source_path="path/to/file.json",
reference_type="branch",
branch_name="develop",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.update_current_model_master_from_git_hub_async({
namespaceName="namespace-0001",
checkoutSetting={
api_key_id="apiKeyId-0001",
repository_name="gs2io/master-data",
source_path="path/to/file.json",
reference_type="branch",
branch_name="develop",
},
})
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeCategoryModelMasters
List Message Category Model Masters
Retrieves a paginated list of Message Category Model Masters in the specified Namespace.
Message Category Model Masters are the editable versions of Message Category Models that define message categories and their posting permissions.
Changes to master data do not take effect until the master data is activated (published) via the Current Model Master.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<CategoryModelMaster>](#categorymodelmaster) | List of Message Category Model Masters |
| nextPageToken | string | Page token to retrieve the rest of the listing |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DescribeCategoryModelMasters(
&chat.DescribeCategoryModelMastersRequest {
NamespaceName: pointy.String("namespace-0001"),
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DescribeCategoryModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->describeCategoryModelMasters(
(new DescribeCategoryModelMastersRequest())
->withNamespaceName("namespace-0001")
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DescribeCategoryModelMastersRequest;
import io.gs2.chat.result.DescribeCategoryModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DescribeCategoryModelMastersResult result = client.describeCategoryModelMasters(
new DescribeCategoryModelMastersRequest()
.withNamespaceName("namespace-0001")
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCategoryModelMasters(
new Gs2.Gs2Chat.Request.DescribeCategoryModelMastersRequest()
.WithNamespaceName("namespace-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;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.describeCategoryModelMasters(
new Gs2Chat.DescribeCategoryModelMastersRequest()
.withNamespaceName("namespace-0001")
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.describe_category_model_masters(
chat.DescribeCategoryModelMastersRequest()
.with_namespace_name('namespace-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)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.describe_category_model_masters({
namespaceName="namespace-0001",
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.describe_category_model_masters_async({
namespaceName="namespace-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['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createCategoryModelMaster
Create Message Category Model Master
Creates a new Message Category Model Master that defines a message category and its posting permissions.
You can configure the category number, description, and the rejectAccessTokenPost flag which controls whether access-token-authenticated users (game players) are allowed to post messages in this category.
When rejectAccessTokenPost is enabled, only server-side (userId-based) posting is allowed for this category, which is useful for system messages or announcements.
Changes do not take effect until the master data is activated (published) via the Current Model Master.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| category | int | | ✓| | 0 ~ 2147483645 | Category
A numeric identifier for the message category. Messages posted with this category number will follow the rules defined in this model, such as whether player posts are allowed or rejected. |
| description | string | | | | ~ 1024 chars | Description |
| rejectAccessTokenPost | string (enum)
enum {
"Enabled",
"Disabled"
}
| | | | | Reject posts made using player access tokens
When enabled, only server-side API calls specifying a user ID can post messages in this category. This is useful for system announcements or server-generated messages that should not be posted by players directly."Enabled": Reject posts made using player access tokens / "Disabled": Allow posts made using player access tokens / |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | Message Category Model Master created |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.CreateCategoryModelMaster(
&chat.CreateCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Category: pointy.Int32(0),
Description: nil,
RejectAccessTokenPost: pointy.String("Disabled"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\CreateCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->createCategoryModelMaster(
(new CreateCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategory(0)
->withDescription(null)
->withRejectAccessTokenPost("Disabled")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.CreateCategoryModelMasterRequest;
import io.gs2.chat.result.CreateCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
CreateCategoryModelMasterResult result = client.createCategoryModelMaster(
new CreateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategory(0)
.withDescription(null)
.withRejectAccessTokenPost("Disabled")
);
CategoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateCategoryModelMaster(
new Gs2.Gs2Chat.Request.CreateCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategory(0)
.WithDescription(null)
.WithRejectAccessTokenPost("Disabled"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.createCategoryModelMaster(
new Gs2Chat.CreateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategory(0)
.withDescription(null)
.withRejectAccessTokenPost("Disabled")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.create_category_model_master(
chat.CreateCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category(0)
.with_description(None)
.with_reject_access_token_post('Disabled')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.create_category_model_master({
namespaceName="namespace-0001",
category=0,
description=nil,
rejectAccessTokenPost="Disabled",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.create_category_model_master_async({
namespaceName="namespace-0001",
category=0,
description=nil,
rejectAccessTokenPost="Disabled",
})
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getCategoryModelMaster
Get Message Category Model Master
Retrieves a specific Message Category Model Master by category number in the specified Namespace.
The retrieved information includes the description and the rejectAccessTokenPost flag for editing purposes.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| category | int | | ✓| | 0 ~ 2147483645 | Category
A numeric identifier for the message category. Messages posted with this category number will follow the rules defined in this model, such as whether player posts are allowed or rejected. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | Message Category Model Master |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.GetCategoryModelMaster(
&chat.GetCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Category: pointy.Int32(0),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\GetCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->getCategoryModelMaster(
(new GetCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategory(0)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.GetCategoryModelMasterRequest;
import io.gs2.chat.result.GetCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
GetCategoryModelMasterResult result = client.getCategoryModelMaster(
new GetCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategory(0)
);
CategoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCategoryModelMaster(
new Gs2.Gs2Chat.Request.GetCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategory(0),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.getCategoryModelMaster(
new Gs2Chat.GetCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategory(0)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.get_category_model_master(
chat.GetCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category(0)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.get_category_model_master({
namespaceName="namespace-0001",
category=0,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.get_category_model_master_async({
namespaceName="namespace-0001",
category=0,
})
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateCategoryModelMaster
Update Message Category Model Master
Updates the specified Message Category Model Master.
You can change the description and the rejectAccessTokenPost flag that controls whether access-token-authenticated users can post to this category.
Changes do not take effect until the master data is activated (published) via the Current Model Master.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| category | int | | ✓| | 0 ~ 2147483645 | Category
A numeric identifier for the message category. Messages posted with this category number will follow the rules defined in this model, such as whether player posts are allowed or rejected. |
| description | string | | | | ~ 1024 chars | Description |
| rejectAccessTokenPost | string (enum)
enum {
"Enabled",
"Disabled"
}
| | | | | Reject posts made using player access tokens
When enabled, only server-side API calls specifying a user ID can post messages in this category. This is useful for system announcements or server-generated messages that should not be posted by players directly."Enabled": Reject posts made using player access tokens / "Disabled": Allow posts made using player access tokens / |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | Message Category Model Master updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.UpdateCategoryModelMaster(
&chat.UpdateCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Category: pointy.Int32(0),
Description: pointy.String("description1"),
RejectAccessTokenPost: pointy.String("Enabled"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\UpdateCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->updateCategoryModelMaster(
(new UpdateCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategory(0)
->withDescription("description1")
->withRejectAccessTokenPost("Enabled")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.UpdateCategoryModelMasterRequest;
import io.gs2.chat.result.UpdateCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
UpdateCategoryModelMasterResult result = client.updateCategoryModelMaster(
new UpdateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategory(0)
.withDescription("description1")
.withRejectAccessTokenPost("Enabled")
);
CategoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCategoryModelMaster(
new Gs2.Gs2Chat.Request.UpdateCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategory(0)
.WithDescription("description1")
.WithRejectAccessTokenPost("Enabled"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.updateCategoryModelMaster(
new Gs2Chat.UpdateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategory(0)
.withDescription("description1")
.withRejectAccessTokenPost("Enabled")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.update_category_model_master(
chat.UpdateCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category(0)
.with_description('description1')
.with_reject_access_token_post('Enabled')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.update_category_model_master({
namespaceName="namespace-0001",
category=0,
description="description1",
rejectAccessTokenPost="Enabled",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.update_category_model_master_async({
namespaceName="namespace-0001",
category=0,
description="description1",
rejectAccessTokenPost="Enabled",
})
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteCategoryModelMaster
Delete Message Category Model Master
Deletes the specified Message Category Model Master from the specified Namespace.
Once deleted, this category will no longer be available after the next master data activation.
This operation only affects the master data; the currently active model remains unchanged until the master data is re-activated.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| category | int | | ✓| | 0 ~ 2147483645 | Category
A numeric identifier for the message category. Messages posted with this category number will follow the rules defined in this model, such as whether player posts are allowed or rejected. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | Message Category Model Master deleted |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/chat"
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 := chat.Gs2ChatRestClient{
Session: &session,
}
result, err := client.DeleteCategoryModelMaster(
&chat.DeleteCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Category: pointy.Int32(0),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Chat\Gs2ChatRestClient;
use Gs2\Chat\Request\DeleteCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2ChatRestClient(
$session
);
try {
$result = $client->deleteCategoryModelMaster(
(new DeleteCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategory(0)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
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.chat.rest.Gs2ChatRestClient;
import io.gs2.chat.request.DeleteCategoryModelMasterRequest;
import io.gs2.chat.result.DeleteCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2ChatRestClient client = new Gs2ChatRestClient(session);
try {
DeleteCategoryModelMasterResult result = client.deleteCategoryModelMaster(
new DeleteCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategory(0)
);
CategoryModelMaster item = result.getItem();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2ChatRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteCategoryModelMaster(
new Gs2.Gs2Chat.Request.DeleteCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategory(0),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Chat from '@/gs2/chat';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Chat.Gs2ChatRestClient(session);
try {
const result = await client.deleteCategoryModelMaster(
new Gs2Chat.DeleteCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategory(0)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import chat
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = chat.Gs2ChatRestClient(session)
try:
result = client.delete_category_model_master(
chat.DeleteCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category(0)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('chat')
api_result = client.delete_category_model_master({
namespaceName="namespace-0001",
category=0,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('chat')
api_result_handler = client.delete_category_model_master_async({
namespaceName="namespace-0001",
category=0,
})
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['errorMessage'])
end
result = api_result.result
item = result.item;
```
---