> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Idle SDK API Reference
Specification of models and API references for GS2-Idle 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 when granting idle rewards. |
| receiveScript | [ScriptSetting](#scriptsetting) | | | | | Script setting executed when rewards are received
Script Trigger Reference - [`receive`](../script/#receive) |
| overrideAcquireActionsScriptId | string | | | | ~ 1024 chars | Script GRN for dynamically determining idle reward Acquire Actions
Script Trigger Reference - [`overrideAcquireActions`](../script/#overrideacquireactions) |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Specifies the GS2-Log Namespace for outputting API request and response logs related to idle reward operations. Useful for tracking idle status creation, reward claims, and debugging timing issues. |
| 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
---
### 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:**
updateCurrentCategoryMasterFromGitHub - Update currently active Category Model master data from GitHub
---
### Status
Status
Created when GetIdleStatus is called for the first time, and the idle time count starts from that time.
The idle time count is reset when you receive a reward.
If GS2-Schedule events are associated, you cannot access Category before the event is held, and you cannot create a status.
If an event is associated, the status holds the number of repetitions of the event.
If the current event ID and the event ID at the time of status creation do not match, if the number of repetitions of the current event and the number of repetitions held by the status do not match, or if the status is created before the start time of the event, the waiting time is reset.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| statusId | string | | * | | ~ 1024 chars | Status GRN
* Set automatically by the server |
| categoryName | string | | ✓ | | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
| userId | string | | ✓ | | ~ 128 chars | User ID |
| randomSeed | long | | | 0 | 0 ~ 9223372036854775805 | Random Seed
A seed value used for deterministic random number generation when calculating idle rewards. Ensures that reward calculations are reproducible and consistent, allowing the server to verify reward results. Updated each time rewards are received. |
| idleMinutes | int | | ✓ | | 0 ~ 2147483646 | Idle Minutes
The accumulated idle time in minutes since the last reward claim or status creation. This value is calculated from the elapsed time since idleStartedAt and is capped at maximumIdleMinutes. The number of available rewards is determined by dividing this value by the category model's rewardIntervalMinutes. |
| nextRewardsAt | long | | | | | Time when additional rewards can be obtained next
Unix time, milliseconds |
| maximumIdleMinutes | int | | | 0 | 0 ~ 2147483646 | Maximum Idle Minutes
The maximum idle time in minutes that this status can accumulate. Initialized from the category model's defaultMaximumIdleMinutes when the status is created. Can be increased per-user via acquire actions, allowing premium users or event participants to accumulate more idle rewards. |
| 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:**
describeStatuses - List statuses
describeStatusesByUserId - List statuses by User ID
getStatus - Get Status
getStatusByUserId - Get status by User ID
prediction - List rewards
predictionByUserId - List rewards by User ID
receive - Receive rewards
receiveByUserId - Receive rewards by User ID
increaseMaximumIdleMinutesByUserId - Increase the maximum idle time by User ID
decreaseMaximumIdleMinutes - Decrease the maximum idle time
decreaseMaximumIdleMinutesByUserId - Decrease the maximum idle time by User ID
setMaximumIdleMinutesByUserId - Set the maximum idle time by User ID
---
### CategoryModel
Category Model
A Category Model is an entity that defines a waiting category in which idle rewards can be earned over time.
The settings include information such as the reward for each waiting time and the maximum idle time.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| categoryModelId | string | | * | | ~ 1024 chars | Category Model GRN
* Set automatically by the server |
| name | string | | ✓ | | ~ 128 chars | Category Model name
Unique Category Model name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| metadata | string | | | | ~ 2048 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. |
| rewardIntervalMinutes | int | | ✓ | | 0 ~ 2147483646 | Reward Interval (Minutes)
The time interval in minutes between each idle reward. For example, if set to 60, the user earns one reward unit for every 60 minutes of idle time. The total number of rewards is calculated as (elapsed idle minutes) / rewardIntervalMinutes, cycling through the acquireActions array. |
| defaultMaximumIdleMinutes | int | | ✓ | | 0 ~ 2147483646 | Default Maximum Idle Time (Minutes)
The default maximum idle time in minutes for new statuses in this category. Idle time beyond this limit does not accumulate additional rewards. This value is copied to each status's maximumIdleMinutes when the status is created, and can be extended per-user via transactions. |
| rewardResetMode | string (enum)
enum {
"Reset",
"CarryOver"
}
| | | "Reset" | | Reward Reset Mode
Determines how idle time is handled after the user receives rewards. "Reset" sets the idle time back to zero, meaning any partial interval time is lost. "CarryOver" preserves the remaining time that was not enough to earn an additional reward, so it counts toward the next reward cycle."Reset": Reset waiting time to 0 / "CarryOver": Carry over the remaining time that was insufficient to receive a reward / |
| acquireActions | [List<AcquireActionList>](#acquireactionlist) | | | [] | 1 ~ 100 items | List of acquire actions for each waiting time
Assuming that the waiting time is "X minutes",
"X / rewardIntervalMinutes" will be the number of rewards that can be received, but by looping the elements specified in this array, different rewards can be given for each waiting time. |
| idlePeriodScheduleId | string | | | | ~ 1024 chars | Idle Period Schedule ID
The GRN of a GS2-Schedule event that defines the time period during which idle time accumulates. When set, idle time only counts while the event is active. If the event repeats, the status tracks the repetition count and resets idle time when a new cycle begins, ensuring rewards are calculated per event period. |
| receivePeriodScheduleId | string | | | | ~ 1024 chars | Receive Period Schedule ID
The GRN of a GS2-Schedule event that defines the time window during which users can claim accumulated idle rewards. When set, reward claims are only accepted while the event is active. This allows time-limited reward collection periods separate from the idle accumulation period. |
**Related methods:**
describeCategoryModels - List Category Models
getCategoryModel - Get Category Model
---
### VerifyActionResult
Verify Action execution result
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| action | string (enum)
enum {
}
| | ✓ | | | Type of Verify Action |
| verifyRequest | string | | ✓ | | ~ 524288 chars | JSON string of the request used when executing the action |
| statusCode | int | | | | 0 ~ 999 | Status code |
| verifyResult | string | | | | ~ 1048576 chars | Result content |
**Related models:**
TransactionResult - Transaction Execution Result
---
### ConsumeActionResult
Consume Action execution result
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| action | string (enum)
enum {
}
| | ✓ | | | Type of Consume Action |
| consumeRequest | string | | ✓ | | ~ 524288 chars | JSON string of the request used when executing the action |
| statusCode | int | | | | 0 ~ 999 | Status code |
| consumeResult | string | | | | ~ 1048576 chars | Result content |
**Related models:**
TransactionResult - Transaction Execution Result
---
### AcquireActionResult
Acquire Action execution result
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| action | string (enum)
enum {
}
| | ✓ | | | Type of Acquire Action |
| acquireRequest | string | | ✓ | | ~ 524288 chars | JSON string of the request used when executing the action |
| statusCode | int | | | | 0 ~ 999 | Status code |
| acquireResult | string | | | | ~ 1048576 chars | Result content |
**Related models:**
TransactionResult - Transaction Execution Result
---
### TransactionResult
Transaction Execution Result
Result of a transaction executed using the server-side automatic execution feature
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| transactionId | string | | ✓ | | 36 ~ 36 chars | Transaction ID |
| verifyResults | [List<VerifyActionResult>](#verifyactionresult) | | | | 0 ~ 10 items | List of verify action execution results |
| consumeResults | [List<ConsumeActionResult>](#consumeactionresult) | | | [] | 0 ~ 10 items | List of Consume Action execution results |
| acquireResults | [List<AcquireActionResult>](#acquireactionresult) | | | [] | 0 ~ 100 items | List of Acquire Action execution results |
| hasError | bool | | | false | | Whether an error occurred during transaction execution |
**Related methods:**
receive - Receive rewards
receiveByUserId - Receive rewards by User ID
---
### Config
Configuration
Configuration values applied to transaction variables
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| key | string | | ✓ | | ~ 64 chars | Name |
| value | string | | | | ~ 51200 chars | Value |
---
### AcquireAction
Acquire Action
Represents a single acquire action used as an idle reward. Consists of an action type (e.g., add items, increase currency) and its request parameters. When idle rewards are claimed, these actions are assembled into transactions and executed to deliver the rewards to the user.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| action | string (enum)
enum {
}
| | ✓ | | | Type of Acquire Action |
| request | string | | ✓ | | ~ 524288 chars | JSON string of the request used when executing the action |
**Related methods:**
prediction - List rewards
predictionByUserId - List rewards by User ID
receive - Receive rewards
receiveByUserId - Receive rewards by User ID
**Related models:**
AcquireActionList - Acquire Action List
---
### AcquireActionList
Acquire Action List
A wrapper that groups multiple acquire actions to be granted together for a single reward interval. Each AcquireActionList corresponds to one reward cycle in the category model's acquireActions array, enabling different reward combinations at each interval.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | [] | 0 ~ 100 items | List of Acquire Actions
The collection of acquire actions that are executed together when this reward interval is triggered. Multiple actions can be combined to grant different types of rewards simultaneously for a single idle reward cycle. Up to 100 actions per list. |
**Related models:**
CategoryModel - Category Model
CategoryModelMaster - Category Model Master
---
### CurrentCategoryMaster
Currently active Category Model master data
This master data defines the 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-Idle Master Data Reference](api_reference/idle/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 Category Model Master in a master data format that can be activated
getCurrentCategoryMaster - Get currently active Category Model master data
updateCurrentCategoryMaster - Update currently active Category Model master data
updateCurrentCategoryMasterFromGitHub - Update currently active Category Model master data from GitHub
---
### CategoryModelMaster
Category Model Master
Category Model Master is data used to edit and manage Category Models 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 Category Model actually referenced by the game.
A Category Model is an entity that defines a waiting category in which idle rewards can be earned over time.
The settings include information such as the reward for each waiting time and the maximum idle time.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| categoryModelId | string | | * | | ~ 1024 chars | Category Model Master GRN
* Set automatically by the server |
| name | string | | ✓ | | ~ 128 chars | Category Model name
Unique Category Model name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| description | string | | | | ~ 1024 chars | Description |
| metadata | string | | | | ~ 2048 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. |
| rewardIntervalMinutes | int | | ✓ | | 0 ~ 2147483646 | Reward Interval (Minutes)
The time interval in minutes between each idle reward. For example, if set to 60, the user earns one reward unit for every 60 minutes of idle time. The total number of rewards is calculated as (elapsed idle minutes) / rewardIntervalMinutes, cycling through the acquireActions array. |
| defaultMaximumIdleMinutes | int | | ✓ | | 0 ~ 2147483646 | Default Maximum Idle Time (Minutes)
The default maximum idle time in minutes for new statuses in this category. Idle time beyond this limit does not accumulate additional rewards. This value is copied to each status's maximumIdleMinutes when the status is created, and can be extended per-user via transactions. |
| rewardResetMode | string (enum)
enum {
"Reset",
"CarryOver"
}
| | | "Reset" | | Reward Reset Mode
Determines how idle time is handled after the user receives rewards. "Reset" sets the idle time back to zero, meaning any partial interval time is lost. "CarryOver" preserves the remaining time that was not enough to earn an additional reward, so it counts toward the next reward cycle."Reset": Reset waiting time to 0 / "CarryOver": Carry over the remaining time that was insufficient to receive a reward / |
| acquireActions | [List<AcquireActionList>](#acquireactionlist) | | | [] | 1 ~ 100 items | List of acquire actions for each waiting time
Assuming that the waiting time is "X minutes",
"X / rewardIntervalMinutes" will be the number of rewards that can be received, but by looping the elements specified in this array, different rewards can be given for each waiting time. |
| idlePeriodScheduleId | string | | | | ~ 1024 chars | Idle Period Schedule ID
The GRN of a GS2-Schedule event that defines the time period during which idle time accumulates. When set, idle time only counts while the event is active. If the event repeats, the status tracks the repetition count and resets idle time when a new cycle begins, ensuring rewards are calculated per event period. |
| receivePeriodScheduleId | string | | | | ~ 1024 chars | Receive Period Schedule ID
The GRN of a GS2-Schedule event that defines the time window during which users can claim accumulated idle rewards. When set, reward claims are only accepted while the event is active. This allows time-limited reward collection periods separate from the idle accumulation period. |
| 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 Category Model Masters
createCategoryModelMaster - Create Category Model Master
getCategoryModelMaster - Get Category Model Master
updateCategoryModelMaster - Update Category Model Master
deleteCategoryModelMaster - Delete 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.DescribeNamespacesRequest;
import io.gs2.idle.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2Idle.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 idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.describe_namespaces(
idle.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('idle')
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('idle')
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
Creates a new Namespace for the GS2-Idle service.
You can configure transaction settings, a receiveScript (executed before granting idle rewards to validate or modify the operation), an overrideAcquireActionsScriptId (to modify acquire actions such as applying rate modifiers), and log settings.
After creation, you need to set up category models via master data to define idle reward configurations.
#### 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 when granting idle rewards. |
| receiveScript | [ScriptSetting](#scriptsetting) | | | | | Script setting executed when rewards are received
Script Trigger Reference - [`receive`](../script/#receive) |
| overrideAcquireActionsScriptId | string | | | | ~ 1024 chars | Script GRN for dynamically determining idle reward Acquire Actions
Script Trigger Reference - [`overrideAcquireActions`](../script/#overrideacquireactions) |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Specifies the GS2-Log Namespace for outputting API request and response logs related to idle reward operations. Useful for tracking idle status creation, reward claims, and debugging timing issues. |
#### 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&idle.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
TransactionSetting: &idle.TransactionSetting{
EnableAutoRun: pointy.Bool(false),
QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"),
},
ReceiveScript: nil,
OverrideAcquireActionsScriptId: nil,
LogSetting: &idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting((new \Gs2\Idle\Model\TransactionSetting())
->withEnableAutoRun(false)
->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
->withReceiveScript(null)
->withOverrideAcquireActionsScriptId(null)
->withLogSetting((new \Gs2\Idle\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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.CreateNamespaceRequest;
import io.gs2.idle.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(new io.gs2.idle.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.withReceiveScript(null)
.withOverrideAcquireActionsScriptId(null)
.withLogSetting(new io.gs2.idle.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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2Idle.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(new Gs2.Gs2Idle.Model.TransactionSetting()
.WithEnableAutoRun(false)
.WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.WithReceiveScript(null)
.WithOverrideAcquireActionsScriptId(null)
.WithLogSetting(new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.createNamespace(
new Gs2Idle.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(new Gs2Idle.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.withReceiveScript(null)
.withOverrideAcquireActionsScriptId(null)
.withLogSetting(new Gs2Idle.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 idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.create_namespace(
idle.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_transaction_setting(
idle.TransactionSetting()
.with_enable_auto_run(False)
.with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001'))
.with_receive_script(None)
.with_override_acquire_actions_script_id(None)
.with_log_setting(
idle.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('idle')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
},
receiveScript=nil,
overrideAcquireActionsScriptId=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('idle')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
},
receiveScript=nil,
overrideAcquireActionsScriptId=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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.GetNamespaceStatusRequest;
import io.gs2.idle.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2Idle.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.get_namespace_status(
idle.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
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('idle')
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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.GetNamespaceRequest;
import io.gs2.idle.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.getNamespace(
new Gs2Idle.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.get_namespace(
idle.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
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('idle')
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
Updates the settings of the specified Namespace.
You can modify the description, transaction settings, receiveScript (executed before granting idle rewards), overrideAcquireActionsScriptId (to modify acquire actions), and log settings.
Changes take effect immediately for subsequent 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 (.). |
| description | string | | | | ~ 1024 chars | Description |
| transactionSetting | [TransactionSetting](#transactionsetting) | | ✓| | | Transaction Setting
Configuration for controlling how transactions are processed when granting idle rewards. |
| receiveScript | [ScriptSetting](#scriptsetting) | | | | | Script setting executed when rewards are received
Script Trigger Reference - [`receive`](../script/#receive) |
| overrideAcquireActionsScriptId | string | | | | ~ 1024 chars | Script GRN for dynamically determining idle reward Acquire Actions
Script Trigger Reference - [`overrideAcquireActions`](../script/#overrideacquireactions) |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Specifies the GS2-Log Namespace for outputting API request and response logs related to idle reward operations. Useful for tracking idle status creation, reward claims, and debugging timing issues. |
#### 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&idle.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
TransactionSetting: &idle.TransactionSetting{
EnableAutoRun: pointy.Bool(false),
QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"),
},
ReceiveScript: nil,
OverrideAcquireActionsScriptId: nil,
LogSetting: &idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting((new \Gs2\Idle\Model\TransactionSetting())
->withEnableAutoRun(false)
->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
->withReceiveScript(null)
->withOverrideAcquireActionsScriptId(null)
->withLogSetting((new \Gs2\Idle\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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.UpdateNamespaceRequest;
import io.gs2.idle.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(new io.gs2.idle.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.withReceiveScript(null)
.withOverrideAcquireActionsScriptId(null)
.withLogSetting(new io.gs2.idle.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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2Idle.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(new Gs2.Gs2Idle.Model.TransactionSetting()
.WithEnableAutoRun(false)
.WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.WithReceiveScript(null)
.WithOverrideAcquireActionsScriptId(null)
.WithLogSetting(new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2Idle.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(new Gs2Idle.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.withReceiveScript(null)
.withOverrideAcquireActionsScriptId(null)
.withLogSetting(new Gs2Idle.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 idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.update_namespace(
idle.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_transaction_setting(
idle.TransactionSetting()
.with_enable_auto_run(False)
.with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002'))
.with_receive_script(None)
.with_override_acquire_actions_script_id(None)
.with_log_setting(
idle.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('idle')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
},
receiveScript=nil,
overrideAcquireActionsScriptId=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('idle')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
},
receiveScript=nil,
overrideAcquireActionsScriptId=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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.DeleteNamespaceRequest;
import io.gs2.idle.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2Idle.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.delete_namespace(
idle.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
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('idle')
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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.GetServiceVersionRequest;
import io.gs2.idle.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2Idle.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.get_service_version(
idle.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
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('idle')
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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.DumpUserDataByUserIdRequest;
import io.gs2.idle.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2Idle.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.dump_user_data_by_user_id(
idle.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
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('idle')
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
Returns the URL of the output data when the dump is complete. If the dump is still in progress, the URL will be empty.
The dumped data includes all idle status records for the specified user, compressed in gzip format.
#### 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.idle.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2Idle.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
idle.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('idle')
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('idle')
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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.CleanUserDataByUserIdRequest;
import io.gs2.idle.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2Idle.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.clean_user_data_by_user_id(
idle.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
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('idle')
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
Returns completion status of the clean operation. The clean operation deletes all idle status records for the specified user across all Namespaces owned by the same owner.
#### 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.idle.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2Idle.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
idle.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
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('idle')
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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.idle.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2Idle.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 idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
idle.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('idle')
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('idle')
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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.ImportUserDataByUserIdRequest;
import io.gs2.idle.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2Idle.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.import_user_data_by_user_id(
idle.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('idle')
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('idle')
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
Returns completion status and a URL to the import log when available.
The import processes the uploaded ZIP file containing idle status data, validates the JSON structure, and restores the records for the specified user.
#### 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.CheckImportUserDataByUserIdRequest;
import io.gs2.idle.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2Idle.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 idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.check_import_user_data_by_user_id(
idle.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('idle')
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('idle')
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;
```
---
### describeStatuses
List statuses
Retrieves a paginated list of idle statuses for the authenticated user in the specified Namespace.
Each status represents a per-category idle state, including the time when idle accumulation started and the current maximum idle time.
#### 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 |
| 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<Status>](#status) | List of Status |
| 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.DescribeStatuses(
&idle.DescribeStatusesRequest {
NamespaceName: pointy.String("namespace-0001"),
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\DescribeStatusesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->describeStatuses(
(new DescribeStatusesRequest())
->withNamespaceName("namespace-0001")
->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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.DescribeStatusesRequest;
import io.gs2.idle.result.DescribeStatusesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
DescribeStatusesResult result = client.describeStatuses(
new DescribeStatusesRequest()
.withNamespaceName("namespace-0001")
.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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeStatuses(
new Gs2.Gs2Idle.Request.DescribeStatusesRequest()
.WithNamespaceName("namespace-0001")
.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.describeStatuses(
new Gs2Idle.DescribeStatusesRequest()
.withNamespaceName("namespace-0001")
.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 idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.describe_statuses(
idle.DescribeStatusesRequest()
.with_namespace_name('namespace-0001')
.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('idle')
api_result = client.describe_statuses({
namespaceName="namespace-0001",
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('idle')
api_result_handler = client.describe_statuses_async({
namespaceName="namespace-0001",
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;
```
---
### describeStatusesByUserId
List statuses by User ID
Retrieves a paginated list of idle statuses for the specified user.
Each status represents a per-category idle state, including the time when idle accumulation started and the current maximum idle time.
#### 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 (.). |
| 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<Status>](#status) | List of Status |
| 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.DescribeStatusesByUserId(
&idle.DescribeStatusesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\DescribeStatusesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->describeStatusesByUserId(
(new DescribeStatusesByUserIdRequest())
->withNamespaceName("namespace-0001")
->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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.DescribeStatusesByUserIdRequest;
import io.gs2.idle.result.DescribeStatusesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
DescribeStatusesByUserIdResult result = client.describeStatusesByUserId(
new DescribeStatusesByUserIdRequest()
.withNamespaceName("namespace-0001")
.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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeStatusesByUserId(
new Gs2.Gs2Idle.Request.DescribeStatusesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.describeStatusesByUserId(
new Gs2Idle.DescribeStatusesByUserIdRequest()
.withNamespaceName("namespace-0001")
.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 idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.describe_statuses_by_user_id(
idle.DescribeStatusesByUserIdRequest()
.with_namespace_name('namespace-0001')
.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('idle')
api_result = client.describe_statuses_by_user_id({
namespaceName="namespace-0001",
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('idle')
api_result_handler = client.describe_statuses_by_user_id_async({
namespaceName="namespace-0001",
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;
```
---
### getStatus
Get Status
Retrieves the idle status for a specific category of the authenticated user.
If no status record exists yet, the status is automatically created with the current time as the idle start time and the category model's defaultMaximumIdleMinutes as the maximum idle time.
#### 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 |
| categoryName | string | | ✓| | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Status](#status) | Status |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.GetStatus(
&idle.GetStatusRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
CategoryName: pointy.String("category-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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\GetStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->getStatus(
(new GetStatusRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withCategoryName("category-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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.GetStatusRequest;
import io.gs2.idle.result.GetStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
GetStatusResult result = client.getStatus(
new GetStatusRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCategoryName("category-0001")
);
Status 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetStatus(
new Gs2.Gs2Idle.Request.GetStatusRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithCategoryName("category-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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.getStatus(
new Gs2Idle.GetStatusRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCategoryName("category-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.get_status(
idle.GetStatusRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_category_name('category-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.get_status({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
categoryName="category-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('idle')
api_result_handler = client.get_status_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
categoryName="category-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;
```
---
### getStatusByUserId
Get status by User ID
Retrieves the idle status for a specific category of the specified user.
If no status record exists yet, the status is automatically created with the current time as the idle start time and the category model's defaultMaximumIdleMinutes as the maximum idle time.
#### 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 (.). |
| userId | string | | ✓| | ~ 128 chars | User ID |
| categoryName | string | | ✓| | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Status](#status) | Status |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.GetStatusByUserId(
&idle.GetStatusByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
CategoryName: pointy.String("category-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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\GetStatusByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->getStatusByUserId(
(new GetStatusByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withCategoryName("category-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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.GetStatusByUserIdRequest;
import io.gs2.idle.result.GetStatusByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
GetStatusByUserIdResult result = client.getStatusByUserId(
new GetStatusByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withTimeOffsetToken(null)
);
Status 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetStatusByUserId(
new Gs2.Gs2Idle.Request.GetStatusByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithCategoryName("category-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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.getStatusByUserId(
new Gs2Idle.GetStatusByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.get_status_by_user_id(
idle.GetStatusByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_category_name('category-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.get_status_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-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('idle')
api_result_handler = client.get_status_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-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;
```
---
### prediction
List rewards
Calculates and returns the rewards that would be received based on the current idle time without actually receiving them.
The calculation is based on the elapsed idle time divided by the rewardIntervalMinutes, capped by the maximumIdleMinutes.
This is a read-only operation that does not modify the status or reset the idle timer.
#### 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 |
| categoryName | string | | ✓| | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<AcquireAction>](#acquireaction) | Rewards |
| status | [Status](#status) | Status |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.Prediction(
&idle.PredictionRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
CategoryName: pointy.String("category-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\PredictionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->prediction(
(new PredictionRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withCategoryName("category-0001")
);
$items = $result->getItems();
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.PredictionRequest;
import io.gs2.idle.result.PredictionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
PredictionResult result = client.prediction(
new PredictionRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCategoryName("category-0001")
);
List items = result.getItems();
Status 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.Prediction(
new Gs2.Gs2Idle.Request.PredictionRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithCategoryName("category-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var status = result.Status;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.prediction(
new Gs2Idle.PredictionRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCategoryName("category-0001")
);
const items = result.getItems();
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.prediction(
idle.PredictionRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_category_name('category-0001')
)
items = result.items
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.prediction({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
categoryName="category-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
status = result.status;
```
**GS2-Script(Async)**
```lua
client = gs2('idle')
api_result_handler = client.prediction_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
categoryName="category-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;
status = result.status;
```
---
### predictionByUserId
List rewards by User ID
Calculates and returns the rewards that would be received for the specified user based on their current idle time without actually receiving them.
The calculation is based on the elapsed idle time divided by the rewardIntervalMinutes, capped by the maximumIdleMinutes.
This is a read-only operation that does not modify the status or reset the idle timer.
#### 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 (.). |
| userId | string | | ✓| | ~ 128 chars | User ID |
| categoryName | string | | ✓| | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<AcquireAction>](#acquireaction) | Rewards |
| status | [Status](#status) | Status |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.PredictionByUserId(
&idle.PredictionByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
CategoryName: pointy.String("category-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\PredictionByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->predictionByUserId(
(new PredictionByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withCategoryName("category-0001")
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.PredictionByUserIdRequest;
import io.gs2.idle.result.PredictionByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
PredictionByUserIdResult result = client.predictionByUserId(
new PredictionByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withTimeOffsetToken(null)
);
List items = result.getItems();
Status 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.PredictionByUserId(
new Gs2.Gs2Idle.Request.PredictionByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithCategoryName("category-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var status = result.Status;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.predictionByUserId(
new Gs2Idle.PredictionByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withTimeOffsetToken(null)
);
const items = result.getItems();
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.prediction_by_user_id(
idle.PredictionByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_category_name('category-0001')
.with_time_offset_token(None)
)
items = result.items
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.prediction_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-0001",
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;
status = result.status;
```
**GS2-Script(Async)**
```lua
client = gs2('idle')
api_result_handler = client.prediction_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-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
items = result.items;
status = result.status;
```
---
### receive
Receive rewards
Receives idle rewards for the specified category based on the accumulated idle time.
The reward amount is calculated from the elapsed idle time divided by rewardIntervalMinutes, capped by maximumIdleMinutes.
If a receiveScript is configured, it is executed before granting rewards and can modify or reject the receive operation.
An overrideAcquireActionsScriptId can also modify the acquire actions (e.g., applying rate modifiers).
After receiving, the idle timer is reset to the current time. If rewardResetMode is set, the idle timer behavior may vary.
Returns a transaction containing the acquire actions for the calculated rewards.
#### 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 |
| categoryName | string | | ✓| | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
| config | [List<Config>](#config) | | | [] | 0 ~ 32 items | Configuration values applied to transaction variables |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<AcquireAction>](#acquireaction) | Rewards |
| status | [Status](#status) | Status updated |
| transactionId | string | Issued transaction ID |
| stampSheet | string | Stamp sheet used to execute the quest initiation process |
| stampSheetEncryptionKeyId | string | Cryptographic key GRN used for stamp sheet signature calculations |
| autoRunStampSheet | bool? | Whether automatic transaction execution is enabled |
| atomicCommit | bool? | Whether to commit the transaction atomically |
| transaction | string | Issued transaction |
| transactionResult | [TransactionResult](#transactionresult) | Transaction Execution Result |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.Receive(
&idle.ReceiveRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
CategoryName: pointy.String("category-0001"),
Config: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
status := result.Status
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet
atomicCommit := result.AtomicCommit
transaction := result.Transaction
transactionResult := result.TransactionResult
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\ReceiveRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->receive(
(new ReceiveRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withCategoryName("category-0001")
->withConfig(null)
);
$items = $result->getItems();
$status = $result->getStatus();
$transactionId = $result->getTransactionId();
$stampSheet = $result->getStampSheet();
$stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
$autoRunStampSheet = $result->getAutoRunStampSheet();
$atomicCommit = $result->getAtomicCommit();
$transaction = $result->getTransaction();
$transactionResult = $result->getTransactionResult();
} 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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.ReceiveRequest;
import io.gs2.idle.result.ReceiveResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
ReceiveResult result = client.receive(
new ReceiveRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCategoryName("category-0001")
.withConfig(null)
);
List items = result.getItems();
Status status = result.getStatus();
String transactionId = result.getTransactionId();
String stampSheet = result.getStampSheet();
String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
boolean autoRunStampSheet = result.getAutoRunStampSheet();
boolean atomicCommit = result.getAtomicCommit();
String transaction = result.getTransaction();
TransactionResult transactionResult = result.getTransactionResult();
} 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.Receive(
new Gs2.Gs2Idle.Request.ReceiveRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithCategoryName("category-0001")
.WithConfig(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var status = result.Status;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.receive(
new Gs2Idle.ReceiveRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCategoryName("category-0001")
.withConfig(null)
);
const items = result.getItems();
const status = result.getStatus();
const transactionId = result.getTransactionId();
const stampSheet = result.getStampSheet();
const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
const autoRunStampSheet = result.getAutoRunStampSheet();
const atomicCommit = result.getAtomicCommit();
const transaction = result.getTransaction();
const transactionResult = result.getTransactionResult();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.receive(
idle.ReceiveRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_category_name('category-0001')
.with_config(None)
)
items = result.items
status = result.status
transaction_id = result.transaction_id
stamp_sheet = result.stamp_sheet
stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
auto_run_stamp_sheet = result.auto_run_stamp_sheet
atomic_commit = result.atomic_commit
transaction = result.transaction
transaction_result = result.transaction_result
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.receive({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
categoryName="category-0001",
config=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
status = result.status;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
**GS2-Script(Async)**
```lua
client = gs2('idle')
api_result_handler = client.receive_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
categoryName="category-0001",
config=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;
status = result.status;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### receiveByUserId
Receive rewards by User ID
Receives idle rewards for the specified user and category based on the accumulated idle time.
The reward amount is calculated from the elapsed idle time divided by rewardIntervalMinutes, capped by maximumIdleMinutes.
If a receiveScript is configured, it is executed before granting rewards and can modify or reject the receive operation.
An overrideAcquireActionsScriptId can also modify the acquire actions (e.g., applying rate modifiers).
After receiving, the idle timer is reset to the current time.
Returns a transaction containing the acquire actions for the calculated rewards.
#### 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 (.). |
| userId | string | | ✓| | ~ 128 chars | User ID |
| categoryName | string | | ✓| | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
| config | [List<Config>](#config) | | | [] | 0 ~ 32 items | Configuration values applied to transaction variables |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<AcquireAction>](#acquireaction) | Rewards |
| status | [Status](#status) | Status updated |
| transactionId | string | Issued transaction ID |
| stampSheet | string | Stamp sheet used to execute the quest initiation process |
| stampSheetEncryptionKeyId | string | Cryptographic key GRN used for stamp sheet signature calculations |
| autoRunStampSheet | bool? | Whether automatic transaction execution is enabled |
| atomicCommit | bool? | Whether to commit the transaction atomically |
| transaction | string | Issued transaction |
| transactionResult | [TransactionResult](#transactionresult) | Transaction Execution Result |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.ReceiveByUserId(
&idle.ReceiveByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
CategoryName: pointy.String("category-0001"),
Config: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
status := result.Status
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet
atomicCommit := result.AtomicCommit
transaction := result.Transaction
transactionResult := result.TransactionResult
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\ReceiveByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->receiveByUserId(
(new ReceiveByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withCategoryName("category-0001")
->withConfig(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$status = $result->getStatus();
$transactionId = $result->getTransactionId();
$stampSheet = $result->getStampSheet();
$stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
$autoRunStampSheet = $result->getAutoRunStampSheet();
$atomicCommit = $result->getAtomicCommit();
$transaction = $result->getTransaction();
$transactionResult = $result->getTransactionResult();
} 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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.ReceiveByUserIdRequest;
import io.gs2.idle.result.ReceiveByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
ReceiveByUserIdResult result = client.receiveByUserId(
new ReceiveByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withConfig(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
Status status = result.getStatus();
String transactionId = result.getTransactionId();
String stampSheet = result.getStampSheet();
String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
boolean autoRunStampSheet = result.getAutoRunStampSheet();
boolean atomicCommit = result.getAtomicCommit();
String transaction = result.getTransaction();
TransactionResult transactionResult = result.getTransactionResult();
} 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.ReceiveByUserId(
new Gs2.Gs2Idle.Request.ReceiveByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithCategoryName("category-0001")
.WithConfig(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var status = result.Status;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.receiveByUserId(
new Gs2Idle.ReceiveByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withConfig(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const status = result.getStatus();
const transactionId = result.getTransactionId();
const stampSheet = result.getStampSheet();
const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
const autoRunStampSheet = result.getAutoRunStampSheet();
const atomicCommit = result.getAtomicCommit();
const transaction = result.getTransaction();
const transactionResult = result.getTransactionResult();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.receive_by_user_id(
idle.ReceiveByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_category_name('category-0001')
.with_config(None)
.with_time_offset_token(None)
)
items = result.items
status = result.status
transaction_id = result.transaction_id
stamp_sheet = result.stamp_sheet
stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
auto_run_stamp_sheet = result.auto_run_stamp_sheet
atomic_commit = result.atomic_commit
transaction = result.transaction
transaction_result = result.transaction_result
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.receive_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-0001",
config=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;
status = result.status;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
**GS2-Script(Async)**
```lua
client = gs2('idle')
api_result_handler = client.receive_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-0001",
config=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;
status = result.status;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### increaseMaximumIdleMinutesByUserId
Increase the maximum idle time by User ID
Adds the specified number of minutes to the user's maximum idle time for the given category.
The maximum idle time determines the cap on how long idle rewards can accumulate.
If no status exists yet, it is automatically created before applying the increase.
#### 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 (.). |
| userId | string | | ✓| | ~ 128 chars | User ID |
| categoryName | string | | ✓| | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
| increaseMinutes | int | | | | 1 ~ 2147483646 | Minutes to increase the maximum idle time |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Status](#status) | Status updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.IncreaseMaximumIdleMinutesByUserId(
&idle.IncreaseMaximumIdleMinutesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
CategoryName: pointy.String("category-0001"),
IncreaseMinutes: pointy.Int32(5),
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\IncreaseMaximumIdleMinutesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->increaseMaximumIdleMinutesByUserId(
(new IncreaseMaximumIdleMinutesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withCategoryName("category-0001")
->withIncreaseMinutes(5)
->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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.IncreaseMaximumIdleMinutesByUserIdRequest;
import io.gs2.idle.result.IncreaseMaximumIdleMinutesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
IncreaseMaximumIdleMinutesByUserIdResult result = client.increaseMaximumIdleMinutesByUserId(
new IncreaseMaximumIdleMinutesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withIncreaseMinutes(5)
.withTimeOffsetToken(null)
);
Status 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.IncreaseMaximumIdleMinutesByUserId(
new Gs2.Gs2Idle.Request.IncreaseMaximumIdleMinutesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithCategoryName("category-0001")
.WithIncreaseMinutes(5)
.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.increaseMaximumIdleMinutesByUserId(
new Gs2Idle.IncreaseMaximumIdleMinutesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withIncreaseMinutes(5)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.increase_maximum_idle_minutes_by_user_id(
idle.IncreaseMaximumIdleMinutesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_category_name('category-0001')
.with_increase_minutes(5)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.increase_maximum_idle_minutes_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-0001",
increaseMinutes=5,
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('idle')
api_result_handler = client.increase_maximum_idle_minutes_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-0001",
increaseMinutes=5,
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;
```
---
### decreaseMaximumIdleMinutes
Decrease the maximum idle time
Subtracts the specified number of minutes from the authenticated user's maximum idle time for the given category.
The maximum idle time cannot go below zero.
If no status exists yet, it is automatically created before applying the decrease.
#### 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 |
| categoryName | string | | ✓| | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
| decreaseMinutes | int | | | | 1 ~ 2147483646 | Minutes to decrease the maximum idle time |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Status](#status) | Status updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.DecreaseMaximumIdleMinutes(
&idle.DecreaseMaximumIdleMinutesRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
CategoryName: pointy.String("category-0001"),
DecreaseMinutes: pointy.Int32(5),
}
)
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\DecreaseMaximumIdleMinutesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->decreaseMaximumIdleMinutes(
(new DecreaseMaximumIdleMinutesRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withCategoryName("category-0001")
->withDecreaseMinutes(5)
);
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.DecreaseMaximumIdleMinutesRequest;
import io.gs2.idle.result.DecreaseMaximumIdleMinutesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
DecreaseMaximumIdleMinutesResult result = client.decreaseMaximumIdleMinutes(
new DecreaseMaximumIdleMinutesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCategoryName("category-0001")
.withDecreaseMinutes(5)
);
Status 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DecreaseMaximumIdleMinutes(
new Gs2.Gs2Idle.Request.DecreaseMaximumIdleMinutesRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithCategoryName("category-0001")
.WithDecreaseMinutes(5),
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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.decreaseMaximumIdleMinutes(
new Gs2Idle.DecreaseMaximumIdleMinutesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCategoryName("category-0001")
.withDecreaseMinutes(5)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.decrease_maximum_idle_minutes(
idle.DecreaseMaximumIdleMinutesRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_category_name('category-0001')
.with_decrease_minutes(5)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.decrease_maximum_idle_minutes({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
categoryName="category-0001",
decreaseMinutes=5,
})
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('idle')
api_result_handler = client.decrease_maximum_idle_minutes_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
categoryName="category-0001",
decreaseMinutes=5,
})
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;
```
---
### decreaseMaximumIdleMinutesByUserId
Decrease the maximum idle time by User ID
Subtracts the specified number of minutes from the user's maximum idle time for the given category.
The maximum idle time cannot go below zero.
If no status exists yet, it is automatically created before applying the decrease.
#### 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 (.). |
| userId | string | | ✓| | ~ 128 chars | User ID |
| categoryName | string | | ✓| | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
| decreaseMinutes | int | | | | 1 ~ 2147483646 | Minutes to decrease the maximum idle time |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Status](#status) | Status updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.DecreaseMaximumIdleMinutesByUserId(
&idle.DecreaseMaximumIdleMinutesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
CategoryName: pointy.String("category-0001"),
DecreaseMinutes: pointy.Int32(5),
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\DecreaseMaximumIdleMinutesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->decreaseMaximumIdleMinutesByUserId(
(new DecreaseMaximumIdleMinutesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withCategoryName("category-0001")
->withDecreaseMinutes(5)
->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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.DecreaseMaximumIdleMinutesByUserIdRequest;
import io.gs2.idle.result.DecreaseMaximumIdleMinutesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
DecreaseMaximumIdleMinutesByUserIdResult result = client.decreaseMaximumIdleMinutesByUserId(
new DecreaseMaximumIdleMinutesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withDecreaseMinutes(5)
.withTimeOffsetToken(null)
);
Status 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DecreaseMaximumIdleMinutesByUserId(
new Gs2.Gs2Idle.Request.DecreaseMaximumIdleMinutesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithCategoryName("category-0001")
.WithDecreaseMinutes(5)
.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.decreaseMaximumIdleMinutesByUserId(
new Gs2Idle.DecreaseMaximumIdleMinutesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withDecreaseMinutes(5)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.decrease_maximum_idle_minutes_by_user_id(
idle.DecreaseMaximumIdleMinutesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_category_name('category-0001')
.with_decrease_minutes(5)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.decrease_maximum_idle_minutes_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-0001",
decreaseMinutes=5,
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('idle')
api_result_handler = client.decrease_maximum_idle_minutes_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-0001",
decreaseMinutes=5,
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;
```
---
### setMaximumIdleMinutesByUserId
Set the maximum idle time by User ID
Sets the user's maximum idle time for the given category to the specified absolute value.
Unlike increase/decrease operations, this directly replaces the current maximum idle time.
Returns both the updated status and the status before the update, allowing the caller to see what changed.
If no status exists yet, it is automatically created before applying the value.
#### 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 (.). |
| userId | string | | ✓| | ~ 128 chars | User ID |
| categoryName | string | | ✓| | ~ 128 chars | Category Model Name
The name of the category model that this status belongs to. References the category model definition which contains the reward interval, maximum idle time, acquire actions, and schedule settings used for idle reward calculation. |
| maximumIdleMinutes | int | | | | 1 ~ 2147483646 | Maximum idle time to set |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [Status](#status) | Status updated |
| old | [Status](#status) | Status before update |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.SetMaximumIdleMinutesByUserId(
&idle.SetMaximumIdleMinutesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
CategoryName: pointy.String("category-0001"),
MaximumIdleMinutes: pointy.Int32(5),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
old := result.Old
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\SetMaximumIdleMinutesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->setMaximumIdleMinutesByUserId(
(new SetMaximumIdleMinutesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withCategoryName("category-0001")
->withMaximumIdleMinutes(5)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$old = $result->getOld();
} 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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.SetMaximumIdleMinutesByUserIdRequest;
import io.gs2.idle.result.SetMaximumIdleMinutesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
SetMaximumIdleMinutesByUserIdResult result = client.setMaximumIdleMinutesByUserId(
new SetMaximumIdleMinutesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withMaximumIdleMinutes(5)
.withTimeOffsetToken(null)
);
Status item = result.getItem();
Status old = result.getOld();
} 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.SetMaximumIdleMinutesByUserId(
new Gs2.Gs2Idle.Request.SetMaximumIdleMinutesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithCategoryName("category-0001")
.WithMaximumIdleMinutes(5)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var old = result.Old;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.setMaximumIdleMinutesByUserId(
new Gs2Idle.SetMaximumIdleMinutesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCategoryName("category-0001")
.withMaximumIdleMinutes(5)
.withTimeOffsetToken(null)
);
const item = result.getItem();
const old = result.getOld();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.set_maximum_idle_minutes_by_user_id(
idle.SetMaximumIdleMinutesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_category_name('category-0001')
.with_maximum_idle_minutes(5)
.with_time_offset_token(None)
)
item = result.item
old = result.old
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.set_maximum_idle_minutes_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-0001",
maximumIdleMinutes=5,
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;
old = result.old;
```
**GS2-Script(Async)**
```lua
client = gs2('idle')
api_result_handler = client.set_maximum_idle_minutes_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
categoryName="category-0001",
maximumIdleMinutes=5,
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;
old = result.old;
```
---
### describeCategoryModels
List Category Models
Retrieves the list of currently active (published) category models in the specified Namespace.
These are the models that have been activated via the master data update process and define the idle reward configuration available to players.
Each model contains settings such as reward interval, maximum idle time, reward reset mode, acquire actions, and schedule references.
#### 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 Category Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.DescribeCategoryModels(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\DescribeCategoryModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.DescribeCategoryModelsRequest;
import io.gs2.idle.result.DescribeCategoryModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCategoryModels(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.describeCategoryModels(
new Gs2Idle.DescribeCategoryModelsRequest()
.withNamespaceName("namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.describe_category_models(
idle.DescribeCategoryModelsRequest()
.with_namespace_name('namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
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('idle')
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 Category Model
Retrieves the details of a specific active category model by name.
The model defines the idle reward configuration including rewardIntervalMinutes (how often rewards accumulate), defaultMaximumIdleMinutes (cap on idle time), acquireActions (rewards to grant), and optional schedule references for controlling idle and receive periods.
#### 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 (.). |
| categoryName | string | | ✓| | ~ 128 chars | Category Model name
Unique Category Model name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CategoryModel](#categorymodel) | Category Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.GetCategoryModel(
&idle.GetCategoryModelRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\GetCategoryModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->getCategoryModel(
(new GetCategoryModelRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.GetCategoryModelRequest;
import io.gs2.idle.result.GetCategoryModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
GetCategoryModelResult result = client.getCategoryModel(
new GetCategoryModelRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCategoryModel(
new Gs2.Gs2Idle.Request.GetCategoryModelRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.getCategoryModel(
new Gs2Idle.GetCategoryModelRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.get_category_model(
idle.GetCategoryModelRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.get_category_model({
namespaceName="namespace-0001",
categoryName="category-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('idle')
api_result_handler = client.get_category_model_async({
namespaceName="namespace-0001",
categoryName="category-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;
```
---
### exportMaster
Export Category Model Master in a master data format that can be activated
Exports all category model masters in the Namespace as a JSON document suitable for activation.
The exported data includes the complete configuration of each category model (reward interval, maximum idle time, reward reset mode, acquire actions, schedule references).
This data can be used to activate the master data in another Namespace or stored for version control 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 (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CurrentCategoryMaster](#currentcategorymaster) | 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.ExportMaster(
&idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\ExportMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.ExportMasterRequest;
import io.gs2.idle.result.ExportMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
ExportMasterResult result = client.exportMaster(
new ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentCategoryMaster 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExportMaster(
new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.exportMaster(
new Gs2Idle.ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.export_master(
idle.ExportMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
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('idle')
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;
```
---
### getCurrentCategoryMaster
Get currently active Category Model master data
Retrieves the currently active master data that defines which category models are available in the Namespace.
This is the data that was last activated and is being used to serve category model requests to players.
#### 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 | [CurrentCategoryMaster](#currentcategorymaster) | Currently active Category Model master data |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.GetCurrentCategoryMaster(
&idle.GetCurrentCategoryMasterRequest {
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\GetCurrentCategoryMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->getCurrentCategoryMaster(
(new GetCurrentCategoryMasterRequest())
->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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.GetCurrentCategoryMasterRequest;
import io.gs2.idle.result.GetCurrentCategoryMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
GetCurrentCategoryMasterResult result = client.getCurrentCategoryMaster(
new GetCurrentCategoryMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentCategoryMaster 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCurrentCategoryMaster(
new Gs2.Gs2Idle.Request.GetCurrentCategoryMasterRequest()
.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.getCurrentCategoryMaster(
new Gs2Idle.GetCurrentCategoryMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.get_current_category_master(
idle.GetCurrentCategoryMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.get_current_category_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('idle')
api_result_handler = client.get_current_category_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;
```
---
### preUpdateCurrentCategoryMaster
Update currently active 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 UpdateCurrentCategoryMaster 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.PreUpdateCurrentCategoryMaster(
&idle.PreUpdateCurrentCategoryMasterRequest {
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\PreUpdateCurrentCategoryMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->preUpdateCurrentCategoryMaster(
(new PreUpdateCurrentCategoryMasterRequest())
->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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.PreUpdateCurrentCategoryMasterRequest;
import io.gs2.idle.result.PreUpdateCurrentCategoryMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
PreUpdateCurrentCategoryMasterResult result = client.preUpdateCurrentCategoryMaster(
new PreUpdateCurrentCategoryMasterRequest()
.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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.PreUpdateCurrentCategoryMaster(
new Gs2.Gs2Idle.Request.PreUpdateCurrentCategoryMasterRequest()
.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.preUpdateCurrentCategoryMaster(
new Gs2Idle.PreUpdateCurrentCategoryMasterRequest()
.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 idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.pre_update_current_category_master(
idle.PreUpdateCurrentCategoryMasterRequest()
.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('idle')
api_result = client.pre_update_current_category_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('idle')
api_result_handler = client.pre_update_current_category_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;
```
---
### updateCurrentCategoryMaster
Update currently active Category Model master data
Activates new master data to replace the currently active category models.
Supports two modes: "direct" for inline JSON data (suitable for small payloads), and "preUpload" for data uploaded via a presigned URL (required for data exceeding 1MB, using the token obtained from PreUpdate).
After activation, the new category models become immediately available for idle reward processing.
#### 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 | [CurrentCategoryMaster](#currentcategorymaster) | Updated master data of the currently active Category Models |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.UpdateCurrentCategoryMaster(
&idle.UpdateCurrentCategoryMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Mode: pointy.String("direct"),
Settings: pointy.String("{\"version\": \"2023-06-06\", \"categoryModels\": [{\"name\": \"category-0001\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"rewardResetMode\": \"Reset\", \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}]}, {\"name\": \"category-0002\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}], \"idlePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\", \"receivePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0002\"}]}"),
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\UpdateCurrentCategoryMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->updateCurrentCategoryMaster(
(new UpdateCurrentCategoryMasterRequest())
->withNamespaceName("namespace-0001")
->withMode("direct")
->withSettings("{\"version\": \"2023-06-06\", \"categoryModels\": [{\"name\": \"category-0001\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"rewardResetMode\": \"Reset\", \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}]}, {\"name\": \"category-0002\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}], \"idlePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\", \"receivePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0002\"}]}")
->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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.UpdateCurrentCategoryMasterRequest;
import io.gs2.idle.result.UpdateCurrentCategoryMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
UpdateCurrentCategoryMasterResult result = client.updateCurrentCategoryMaster(
new UpdateCurrentCategoryMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\"version\": \"2023-06-06\", \"categoryModels\": [{\"name\": \"category-0001\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"rewardResetMode\": \"Reset\", \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}]}, {\"name\": \"category-0002\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}], \"idlePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\", \"receivePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0002\"}]}")
.withUploadToken(null)
);
CurrentCategoryMaster 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentCategoryMaster(
new Gs2.Gs2Idle.Request.UpdateCurrentCategoryMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMode("direct")
.WithSettings("{\"version\": \"2023-06-06\", \"categoryModels\": [{\"name\": \"category-0001\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"rewardResetMode\": \"Reset\", \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}]}, {\"name\": \"category-0002\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}], \"idlePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\", \"receivePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0002\"}]}")
.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.updateCurrentCategoryMaster(
new Gs2Idle.UpdateCurrentCategoryMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\"version\": \"2023-06-06\", \"categoryModels\": [{\"name\": \"category-0001\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"rewardResetMode\": \"Reset\", \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}]}, {\"name\": \"category-0002\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}], \"idlePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\", \"receivePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0002\"}]}")
.withUploadToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.update_current_category_master(
idle.UpdateCurrentCategoryMasterRequest()
.with_namespace_name('namespace-0001')
.with_mode('direct')
.with_settings('{"version": "2023-06-06", "categoryModels": [{"name": "category-0001", "rewardIntervalMinutes": 5, "defaultMaximumIdleMinutes": 1440, "rewardResetMode": "Reset", "acquireActions": [{"acquireActions": [{"action": "Gs2Experience:AddExperienceByUserId", "request": {"namespaceName": "namespace-0001", "experienceName": "player", "userId": "#{userId}", "propertyId": "player", "experienceValue": 10}}]}, {"acquireActions": [{"action": "Gs2Experience:AddExperienceByUserId", "request": {"namespaceName": "namespace-0001", "experienceName": "player", "userId": "#{userId}", "propertyId": "player", "experienceValue": 5}}]}]}, {"name": "category-0002", "rewardIntervalMinutes": 5, "defaultMaximumIdleMinutes": 1440, "acquireActions": [{"acquireActions": [{"action": "Gs2Experience:AddExperienceByUserId", "request": {"namespaceName": "namespace-0001", "experienceName": "player", "userId": "#{userId}", "propertyId": "player", "experienceValue": 10}}]}, {"acquireActions": [{"action": "Gs2Experience:AddExperienceByUserId", "request": {"namespaceName": "namespace-0001", "experienceName": "player", "userId": "#{userId}", "propertyId": "player", "experienceValue": 5}}]}], "idlePeriodScheduleId": "grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001", "receivePeriodScheduleId": "grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0002"}]}')
.with_upload_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.update_current_category_master({
namespaceName="namespace-0001",
mode="direct",
settings="{\"version\": \"2023-06-06\", \"categoryModels\": [{\"name\": \"category-0001\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"rewardResetMode\": \"Reset\", \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}]}, {\"name\": \"category-0002\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}], \"idlePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\", \"receivePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0002\"}]}",
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('idle')
api_result_handler = client.update_current_category_master_async({
namespaceName="namespace-0001",
mode="direct",
settings="{\"version\": \"2023-06-06\", \"categoryModels\": [{\"name\": \"category-0001\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"rewardResetMode\": \"Reset\", \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}]}, {\"name\": \"category-0002\", \"rewardIntervalMinutes\": 5, \"defaultMaximumIdleMinutes\": 1440, \"acquireActions\": [{\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 10}}]}, {\"acquireActions\": [{\"action\": \"Gs2Experience:AddExperienceByUserId\", \"request\": {\"namespaceName\": \"namespace-0001\", \"experienceName\": \"player\", \"userId\": \"#{userId}\", \"propertyId\": \"player\", \"experienceValue\": 5}}]}], \"idlePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0001\", \"receivePeriodScheduleId\": \"grn:gs2:ap-northeast-1:YourOwnerId:schedule:namespace-0001:event:event-0002\"}]}",
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;
```
---
### updateCurrentCategoryMasterFromGitHub
Update currently active Category Model master data from GitHub
Fetches master data from a GitHub repository and activates it as the current category model configuration.
The checkout setting specifies the repository, branch/tag, and file path to retrieve the master data JSON.
This enables GitOps-style management of idle reward configurations with version control.
#### 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 | [CurrentCategoryMaster](#currentcategorymaster) | Updated master data of the currently active Category Models |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.UpdateCurrentCategoryMasterFromGitHub(
&idle.UpdateCurrentCategoryMasterFromGitHubRequest {
NamespaceName: pointy.String("namespace-0001"),
CheckoutSetting: &idle.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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\UpdateCurrentCategoryMasterFromGitHubRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->updateCurrentCategoryMasterFromGitHub(
(new UpdateCurrentCategoryMasterFromGitHubRequest())
->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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.UpdateCurrentCategoryMasterFromGitHubRequest;
import io.gs2.idle.result.UpdateCurrentCategoryMasterFromGitHubResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
UpdateCurrentCategoryMasterFromGitHubResult result = client.updateCurrentCategoryMasterFromGitHub(
new UpdateCurrentCategoryMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
CurrentCategoryMaster 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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentCategoryMasterFromGitHub(
new Gs2.Gs2Idle.Request.UpdateCurrentCategoryMasterFromGitHubRequest()
.WithNamespaceName("namespace-0001")
.WithCheckoutSetting(new Gs2.Gs2Idle.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.updateCurrentCategoryMasterFromGitHub(
new Gs2Idle.UpdateCurrentCategoryMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new Gs2Idle.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 idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.update_current_category_master_from_git_hub(
idle.UpdateCurrentCategoryMasterFromGitHubRequest()
.with_namespace_name('namespace-0001')
.with_checkout_setting(idle.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('idle')
api_result = client.update_current_category_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('idle')
api_result_handler = client.update_current_category_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 Category Model Masters
Retrieves a paginated list of editable category model masters in the specified Namespace.
Category model masters are the editable versions of category models that define idle reward configurations.
Changes to masters do not take effect until they are activated through the current master data update process.
#### 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<CategoryModelMaster>](#categorymodelmaster) | List of 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/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.DescribeCategoryModelMasters(
&idle.DescribeCategoryModelMastersRequest {
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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\DescribeCategoryModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->describeCategoryModelMasters(
(new DescribeCategoryModelMastersRequest())
->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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.DescribeCategoryModelMastersRequest;
import io.gs2.idle.result.DescribeCategoryModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
DescribeCategoryModelMastersResult result = client.describeCategoryModelMasters(
new DescribeCategoryModelMastersRequest()
.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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCategoryModelMasters(
new Gs2.Gs2Idle.Request.DescribeCategoryModelMastersRequest()
.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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.describeCategoryModelMasters(
new Gs2Idle.DescribeCategoryModelMastersRequest()
.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 idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.describe_category_model_masters(
idle.DescribeCategoryModelMastersRequest()
.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('idle')
api_result = client.describe_category_model_masters({
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('idle')
api_result_handler = client.describe_category_model_masters_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;
```
---
### createCategoryModelMaster
Create Category Model Master
Creates a new editable category model master that defines an idle reward configuration.
Key settings include rewardIntervalMinutes (how often rewards accumulate), defaultMaximumIdleMinutes (cap on idle time), rewardResetMode (whether rewards reset on receive), and acquireActions (the rewards to grant).
Optionally, idlePeriodScheduleId and receivePeriodScheduleId can reference GS2-Schedule events to control when idle accumulation and reward receipt are active.
The created master must be activated through the current master data update process to take effect.
#### 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 | | ✓| | ~ 128 chars | Category Model name
Unique Category Model name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| description | string | | | | ~ 1024 chars | Description |
| metadata | string | | | | ~ 2048 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. |
| rewardIntervalMinutes | int | | ✓| | 0 ~ 2147483646 | Reward Interval (Minutes)
The time interval in minutes between each idle reward. For example, if set to 60, the user earns one reward unit for every 60 minutes of idle time. The total number of rewards is calculated as (elapsed idle minutes) / rewardIntervalMinutes, cycling through the acquireActions array. |
| defaultMaximumIdleMinutes | int | | ✓| | 0 ~ 2147483646 | Default Maximum Idle Time (Minutes)
The default maximum idle time in minutes for new statuses in this category. Idle time beyond this limit does not accumulate additional rewards. This value is copied to each status's maximumIdleMinutes when the status is created, and can be extended per-user via transactions. |
| rewardResetMode | string (enum)
enum {
"Reset",
"CarryOver"
}
| | | "Reset" | | Reward Reset Mode
Determines how idle time is handled after the user receives rewards. "Reset" sets the idle time back to zero, meaning any partial interval time is lost. "CarryOver" preserves the remaining time that was not enough to earn an additional reward, so it counts toward the next reward cycle."Reset": Reset waiting time to 0 / "CarryOver": Carry over the remaining time that was insufficient to receive a reward / |
| acquireActions | [List<AcquireActionList>](#acquireactionlist) | | | [] | 1 ~ 100 items | List of acquire actions for each waiting time
Assuming that the waiting time is "X minutes",
"X / rewardIntervalMinutes" will be the number of rewards that can be received, but by looping the elements specified in this array, different rewards can be given for each waiting time. |
| idlePeriodScheduleId | string | | | | ~ 1024 chars | Idle Period Schedule ID
The GRN of a GS2-Schedule event that defines the time period during which idle time accumulates. When set, idle time only counts while the event is active. If the event repeats, the status tracks the repetition count and resets idle time when a new cycle begins, ensuring rewards are calculated per event period. |
| receivePeriodScheduleId | string | | | | ~ 1024 chars | Receive Period Schedule ID
The GRN of a GS2-Schedule event that defines the time window during which users can claim accumulated idle rewards. When set, reward claims are only accepted while the event is active. This allows time-limited reward collection periods separate from the idle accumulation period. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | Category Model Master created |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.CreateCategoryModelMaster(
&idle.CreateCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("category-model-0001"),
Description: nil,
Metadata: nil,
RewardIntervalMinutes: pointy.Int32(5),
DefaultMaximumIdleMinutes: pointy.Int32(1440),
RewardResetMode: pointy.String("Reset"),
AcquireActions: []idle.AcquireActionList{
idle.AcquireActionList{
AcquireActions: []idle.AcquireAction{
idle.AcquireAction{
Action: pointy.String("Gs2Experience:AddExperienceByUserId"),
Request: pointy.String("Gs2Experience:AddExperienceByUserId-request1"),
},
idle.AcquireAction{
Action: pointy.String("Gs2Experience:AddExperienceByUserId"),
Request: pointy.String("Gs2Experience:AddExperienceByUserId-request2"),
},
},
},
idle.AcquireActionList{
AcquireActions: []idle.AcquireAction{
idle.AcquireAction{
Action: pointy.String("Gs2Experience:AddExperienceByUserId"),
Request: pointy.String("Gs2Experience:AddExperienceByUserId-request3"),
},
},
},
},
IdlePeriodScheduleId: nil,
ReceivePeriodScheduleId: 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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\CreateCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->createCategoryModelMaster(
(new CreateCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withName("category-model-0001")
->withDescription(null)
->withMetadata(null)
->withRewardIntervalMinutes(5)
->withDefaultMaximumIdleMinutes(1440)
->withRewardResetMode("Reset")
->withAcquireActions([
(new \Gs2\Idle\Model\AcquireActionList())
->withAcquireActions([
(new \Gs2\Idle\Model\AcquireAction())
->withAction("Gs2Experience:AddExperienceByUserId")
->withRequest("Gs2Experience:AddExperienceByUserId-request1"),
(new \Gs2\Idle\Model\AcquireAction())
->withAction("Gs2Experience:AddExperienceByUserId")
->withRequest("Gs2Experience:AddExperienceByUserId-request2"),
]),
(new \Gs2\Idle\Model\AcquireActionList())
->withAcquireActions([
(new \Gs2\Idle\Model\AcquireAction())
->withAction("Gs2Experience:AddExperienceByUserId")
->withRequest("Gs2Experience:AddExperienceByUserId-request3"),
]),
])
->withIdlePeriodScheduleId(null)
->withReceivePeriodScheduleId(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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.CreateCategoryModelMasterRequest;
import io.gs2.idle.result.CreateCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
CreateCategoryModelMasterResult result = client.createCategoryModelMaster(
new CreateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("category-model-0001")
.withDescription(null)
.withMetadata(null)
.withRewardIntervalMinutes(5)
.withDefaultMaximumIdleMinutes(1440)
.withRewardResetMode("Reset")
.withAcquireActions(Arrays.asList(
new io.gs2.idle.model.AcquireActionList()
.withAcquireActions(Arrays.asList(
new io.gs2.idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request1"),
new io.gs2.idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request2")
)),
new io.gs2.idle.model.AcquireActionList()
.withAcquireActions(Arrays.asList(
new io.gs2.idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request3")
))
))
.withIdlePeriodScheduleId(null)
.withReceivePeriodScheduleId(null)
);
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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateCategoryModelMaster(
new Gs2.Gs2Idle.Request.CreateCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("category-model-0001")
.WithDescription(null)
.WithMetadata(null)
.WithRewardIntervalMinutes(5)
.WithDefaultMaximumIdleMinutes(1440)
.WithRewardResetMode("Reset")
.WithAcquireActions(new Gs2.Gs2Idle.Model.AcquireActionList[] {
new Gs2.Gs2Idle.Model.AcquireActionList()
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Experience:AddExperienceByUserId")
.WithRequest("Gs2Experience:AddExperienceByUserId-request1"),
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Experience:AddExperienceByUserId")
.WithRequest("Gs2Experience:AddExperienceByUserId-request2"),
}),
new Gs2.Gs2Idle.Model.AcquireActionList()
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Experience:AddExperienceByUserId")
.WithRequest("Gs2Experience:AddExperienceByUserId-request3"),
}),
})
.WithIdlePeriodScheduleId(null)
.WithReceivePeriodScheduleId(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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.createCategoryModelMaster(
new Gs2Idle.CreateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("category-model-0001")
.withDescription(null)
.withMetadata(null)
.withRewardIntervalMinutes(5)
.withDefaultMaximumIdleMinutes(1440)
.withRewardResetMode("Reset")
.withAcquireActions([
new Gs2Idle.model.AcquireActionList()
.withAcquireActions([
new Gs2Idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request1"),
new Gs2Idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request2"),
]),
new Gs2Idle.model.AcquireActionList()
.withAcquireActions([
new Gs2Idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request3"),
]),
])
.withIdlePeriodScheduleId(null)
.withReceivePeriodScheduleId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.create_category_model_master(
idle.CreateCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('category-model-0001')
.with_description(None)
.with_metadata(None)
.with_reward_interval_minutes(5)
.with_default_maximum_idle_minutes(1440)
.with_reward_reset_mode('Reset')
.with_acquire_actions([
idle.AcquireActionList()
.with_acquire_actions([
idle.AcquireAction()
.with_action('Gs2Experience:AddExperienceByUserId')
.with_request('Gs2Experience:AddExperienceByUserId-request1'),
idle.AcquireAction()
.with_action('Gs2Experience:AddExperienceByUserId')
.with_request('Gs2Experience:AddExperienceByUserId-request2'),
]),
idle.AcquireActionList()
.with_acquire_actions([
idle.AcquireAction()
.with_action('Gs2Experience:AddExperienceByUserId')
.with_request('Gs2Experience:AddExperienceByUserId-request3'),
]),
])
.with_idle_period_schedule_id(None)
.with_receive_period_schedule_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.create_category_model_master({
namespaceName="namespace-0001",
name="category-model-0001",
description=nil,
metadata=nil,
rewardIntervalMinutes=5,
defaultMaximumIdleMinutes=1440,
rewardResetMode="Reset",
acquireActions={
{
acquireActions={
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request1",
},
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request2",
}
},
},
{
acquireActions={
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request3",
}
},
}
},
idlePeriodScheduleId=nil,
receivePeriodScheduleId=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('idle')
api_result_handler = client.create_category_model_master_async({
namespaceName="namespace-0001",
name="category-model-0001",
description=nil,
metadata=nil,
rewardIntervalMinutes=5,
defaultMaximumIdleMinutes=1440,
rewardResetMode="Reset",
acquireActions={
{
acquireActions={
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request1",
},
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request2",
}
},
},
{
acquireActions={
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request3",
}
},
}
},
idlePeriodScheduleId=nil,
receivePeriodScheduleId=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;
```
---
### getCategoryModelMaster
Get Category Model Master
Retrieves the details of a specific editable category model master.
Returns the full configuration including reward interval, maximum idle time, reward reset mode, acquire actions, and schedule references.
#### 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 (.). |
| categoryName | string | | ✓| | ~ 128 chars | Category Model name
Unique Category Model name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | Category Model Master |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.GetCategoryModelMaster(
&idle.GetCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-model-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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\GetCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->getCategoryModelMaster(
(new GetCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-model-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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.GetCategoryModelMasterRequest;
import io.gs2.idle.result.GetCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
GetCategoryModelMasterResult result = client.getCategoryModelMaster(
new GetCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-model-0001")
);
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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCategoryModelMaster(
new Gs2.Gs2Idle.Request.GetCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-model-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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.getCategoryModelMaster(
new Gs2Idle.GetCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-model-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.get_category_model_master(
idle.GetCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-model-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.get_category_model_master({
namespaceName="namespace-0001",
categoryName="category-model-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('idle')
api_result_handler = client.get_category_model_master_async({
namespaceName="namespace-0001",
categoryName="category-model-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;
```
---
### updateCategoryModelMaster
Update Category Model Master
Updates the configuration of an existing category model master.
You can modify the reward interval, maximum idle time, reward reset mode, acquire actions, and schedule references.
Changes do not affect the currently active model until the master data is re-activated through the update process.
#### 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 (.). |
| categoryName | string | | ✓| | ~ 128 chars | Category Model name
Unique Category Model name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| description | string | | | | ~ 1024 chars | Description |
| metadata | string | | | | ~ 2048 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. |
| rewardIntervalMinutes | int | | ✓| | 0 ~ 2147483646 | Reward Interval (Minutes)
The time interval in minutes between each idle reward. For example, if set to 60, the user earns one reward unit for every 60 minutes of idle time. The total number of rewards is calculated as (elapsed idle minutes) / rewardIntervalMinutes, cycling through the acquireActions array. |
| defaultMaximumIdleMinutes | int | | ✓| | 0 ~ 2147483646 | Default Maximum Idle Time (Minutes)
The default maximum idle time in minutes for new statuses in this category. Idle time beyond this limit does not accumulate additional rewards. This value is copied to each status's maximumIdleMinutes when the status is created, and can be extended per-user via transactions. |
| rewardResetMode | string (enum)
enum {
"Reset",
"CarryOver"
}
| | | "Reset" | | Reward Reset Mode
Determines how idle time is handled after the user receives rewards. "Reset" sets the idle time back to zero, meaning any partial interval time is lost. "CarryOver" preserves the remaining time that was not enough to earn an additional reward, so it counts toward the next reward cycle."Reset": Reset waiting time to 0 / "CarryOver": Carry over the remaining time that was insufficient to receive a reward / |
| acquireActions | [List<AcquireActionList>](#acquireactionlist) | | | [] | 1 ~ 100 items | List of acquire actions for each waiting time
Assuming that the waiting time is "X minutes",
"X / rewardIntervalMinutes" will be the number of rewards that can be received, but by looping the elements specified in this array, different rewards can be given for each waiting time. |
| idlePeriodScheduleId | string | | | | ~ 1024 chars | Idle Period Schedule ID
The GRN of a GS2-Schedule event that defines the time period during which idle time accumulates. When set, idle time only counts while the event is active. If the event repeats, the status tracks the repetition count and resets idle time when a new cycle begins, ensuring rewards are calculated per event period. |
| receivePeriodScheduleId | string | | | | ~ 1024 chars | Receive Period Schedule ID
The GRN of a GS2-Schedule event that defines the time window during which users can claim accumulated idle rewards. When set, reward claims are only accepted while the event is active. This allows time-limited reward collection periods separate from the idle accumulation period. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | Category Model Master updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.UpdateCategoryModelMaster(
&idle.UpdateCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-model-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("{\"hoge\": \"fuga\"}"),
RewardIntervalMinutes: pointy.Int32(10),
DefaultMaximumIdleMinutes: pointy.Int32(2880),
RewardResetMode: nil,
AcquireActions: []idle.AcquireActionList{
idle.AcquireActionList{
AcquireActions: []idle.AcquireAction{
idle.AcquireAction{
Action: pointy.String("Gs2Experience:AddExperienceByUserId"),
Request: pointy.String("Gs2Experience:AddExperienceByUserId-request4"),
},
idle.AcquireAction{
Action: pointy.String("Gs2Experience:AddExperienceByUserId"),
Request: pointy.String("Gs2Experience:AddExperienceByUserId-request5"),
},
},
},
idle.AcquireActionList{
AcquireActions: []idle.AcquireAction{
idle.AcquireAction{
Action: pointy.String("Gs2Experience:AddExperienceByUserId"),
Request: pointy.String("Gs2Experience:AddExperienceByUserId-request6"),
},
},
},
},
IdlePeriodScheduleId: nil,
ReceivePeriodScheduleId: 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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\UpdateCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->updateCategoryModelMaster(
(new UpdateCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-model-0001")
->withDescription("description1")
->withMetadata("{\"hoge\": \"fuga\"}")
->withRewardIntervalMinutes(10)
->withDefaultMaximumIdleMinutes(2880)
->withRewardResetMode(null)
->withAcquireActions([
(new \Gs2\Idle\Model\AcquireActionList())
->withAcquireActions([
(new \Gs2\Idle\Model\AcquireAction())
->withAction("Gs2Experience:AddExperienceByUserId")
->withRequest("Gs2Experience:AddExperienceByUserId-request4"),
(new \Gs2\Idle\Model\AcquireAction())
->withAction("Gs2Experience:AddExperienceByUserId")
->withRequest("Gs2Experience:AddExperienceByUserId-request5"),
]),
(new \Gs2\Idle\Model\AcquireActionList())
->withAcquireActions([
(new \Gs2\Idle\Model\AcquireAction())
->withAction("Gs2Experience:AddExperienceByUserId")
->withRequest("Gs2Experience:AddExperienceByUserId-request6"),
]),
])
->withIdlePeriodScheduleId(null)
->withReceivePeriodScheduleId(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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.UpdateCategoryModelMasterRequest;
import io.gs2.idle.result.UpdateCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
UpdateCategoryModelMasterResult result = client.updateCategoryModelMaster(
new UpdateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-model-0001")
.withDescription("description1")
.withMetadata("{\"hoge\": \"fuga\"}")
.withRewardIntervalMinutes(10)
.withDefaultMaximumIdleMinutes(2880)
.withRewardResetMode(null)
.withAcquireActions(Arrays.asList(
new io.gs2.idle.model.AcquireActionList()
.withAcquireActions(Arrays.asList(
new io.gs2.idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request4"),
new io.gs2.idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request5")
)),
new io.gs2.idle.model.AcquireActionList()
.withAcquireActions(Arrays.asList(
new io.gs2.idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request6")
))
))
.withIdlePeriodScheduleId(null)
.withReceivePeriodScheduleId(null)
);
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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCategoryModelMaster(
new Gs2.Gs2Idle.Request.UpdateCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-model-0001")
.WithDescription("description1")
.WithMetadata("{\"hoge\": \"fuga\"}")
.WithRewardIntervalMinutes(10)
.WithDefaultMaximumIdleMinutes(2880)
.WithRewardResetMode(null)
.WithAcquireActions(new Gs2.Gs2Idle.Model.AcquireActionList[] {
new Gs2.Gs2Idle.Model.AcquireActionList()
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Experience:AddExperienceByUserId")
.WithRequest("Gs2Experience:AddExperienceByUserId-request4"),
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Experience:AddExperienceByUserId")
.WithRequest("Gs2Experience:AddExperienceByUserId-request5"),
}),
new Gs2.Gs2Idle.Model.AcquireActionList()
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Experience:AddExperienceByUserId")
.WithRequest("Gs2Experience:AddExperienceByUserId-request6"),
}),
})
.WithIdlePeriodScheduleId(null)
.WithReceivePeriodScheduleId(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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.updateCategoryModelMaster(
new Gs2Idle.UpdateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-model-0001")
.withDescription("description1")
.withMetadata("{\"hoge\": \"fuga\"}")
.withRewardIntervalMinutes(10)
.withDefaultMaximumIdleMinutes(2880)
.withRewardResetMode(null)
.withAcquireActions([
new Gs2Idle.model.AcquireActionList()
.withAcquireActions([
new Gs2Idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request4"),
new Gs2Idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request5"),
]),
new Gs2Idle.model.AcquireActionList()
.withAcquireActions([
new Gs2Idle.model.AcquireAction()
.withAction("Gs2Experience:AddExperienceByUserId")
.withRequest("Gs2Experience:AddExperienceByUserId-request6"),
]),
])
.withIdlePeriodScheduleId(null)
.withReceivePeriodScheduleId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.update_category_model_master(
idle.UpdateCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-model-0001')
.with_description('description1')
.with_metadata('{"hoge": "fuga"}')
.with_reward_interval_minutes(10)
.with_default_maximum_idle_minutes(2880)
.with_reward_reset_mode(None)
.with_acquire_actions([
idle.AcquireActionList()
.with_acquire_actions([
idle.AcquireAction()
.with_action('Gs2Experience:AddExperienceByUserId')
.with_request('Gs2Experience:AddExperienceByUserId-request4'),
idle.AcquireAction()
.with_action('Gs2Experience:AddExperienceByUserId')
.with_request('Gs2Experience:AddExperienceByUserId-request5'),
]),
idle.AcquireActionList()
.with_acquire_actions([
idle.AcquireAction()
.with_action('Gs2Experience:AddExperienceByUserId')
.with_request('Gs2Experience:AddExperienceByUserId-request6'),
]),
])
.with_idle_period_schedule_id(None)
.with_receive_period_schedule_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.update_category_model_master({
namespaceName="namespace-0001",
categoryName="category-model-0001",
description="description1",
metadata="{\"hoge\": \"fuga\"}",
rewardIntervalMinutes=10,
defaultMaximumIdleMinutes=2880,
rewardResetMode=nil,
acquireActions={
{
acquireActions={
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request4",
},
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request5",
}
},
},
{
acquireActions={
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request6",
}
},
}
},
idlePeriodScheduleId=nil,
receivePeriodScheduleId=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('idle')
api_result_handler = client.update_category_model_master_async({
namespaceName="namespace-0001",
categoryName="category-model-0001",
description="description1",
metadata="{\"hoge\": \"fuga\"}",
rewardIntervalMinutes=10,
defaultMaximumIdleMinutes=2880,
rewardResetMode=nil,
acquireActions={
{
acquireActions={
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request4",
},
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request5",
}
},
},
{
acquireActions={
{
action="Gs2Experience:AddExperienceByUserId",
request="Gs2Experience:AddExperienceByUserId-request6",
}
},
}
},
idlePeriodScheduleId=nil,
receivePeriodScheduleId=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;
```
---
### deleteCategoryModelMaster
Delete Category Model Master
Deletes the specified category model master.
This does not affect the currently active model; the deletion takes effect only after the master data is re-activated.
Existing user statuses associated with this category are not automatically 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 (.). |
| categoryName | string | | ✓| | ~ 128 chars | Category Model name
Unique Category Model name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | Category Model Master deleted |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/idle"
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 := idle.Gs2IdleRestClient{
Session: &session,
}
result, err := client.DeleteCategoryModelMaster(
&idle.DeleteCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-model-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\Idle\Gs2IdleRestClient;
use Gs2\Idle\Request\DeleteCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2IdleRestClient(
$session
);
try {
$result = $client->deleteCategoryModelMaster(
(new DeleteCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-model-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.idle.rest.Gs2IdleRestClient;
import io.gs2.idle.request.DeleteCategoryModelMasterRequest;
import io.gs2.idle.result.DeleteCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2IdleRestClient client = new Gs2IdleRestClient(session);
try {
DeleteCategoryModelMasterResult result = client.deleteCategoryModelMaster(
new DeleteCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-model-0001")
);
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 Gs2IdleRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteCategoryModelMaster(
new Gs2.Gs2Idle.Request.DeleteCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-model-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 Gs2Idle from '@/gs2/idle';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Idle.Gs2IdleRestClient(session);
try {
const result = await client.deleteCategoryModelMaster(
new Gs2Idle.DeleteCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-model-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import idle
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = idle.Gs2IdleRestClient(session)
try:
result = client.delete_category_model_master(
idle.DeleteCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-model-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('idle')
api_result = client.delete_category_model_master({
namespaceName="namespace-0001",
categoryName="category-model-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('idle')
api_result_handler = client.delete_category_model_master_async({
namespaceName="namespace-0001",
categoryName="category-model-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;
```
---