> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-SerialKey SDK API Reference
Specification of models and API references for GS2-SerialKey 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 executing serial key operations. |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Specifies the GS2-Log Namespace for outputting API request/response logs related to serial code issuance and usage. |
| 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 Settings control how transactions are executed, their consistency, asynchronous processing, and conflict avoidance mechanisms.
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
---
### LogSetting
Log Output Setting
Manages log output settings.
This type holds the identifier of the log Namespace used to output log data.
The log Namespace ID specifies the GS2-Log Namespace to aggregate and store the log data.
Through this setting, API request and response log data under this Namespace will be output to the target GS2-Log.
GS2-Log provides logs in real time, which can be used for system monitoring, analysis, debugging, etc.
| | Type | Condition | 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:**
updateCurrentCampaignMasterFromGitHub - Update currently active Campaign Model master data from GitHub
---
### IssueJob
Serial Code Issuance Job
An entity is created when the serial code issuance process is executed.
The quantity of serial codes issued can range from 1 to 100000, and the progress of the issuing process can be monitored.
When the issuing process is completed, the status will change from PROCESSING to COMPLETE, and you will be able to access information about the serial code issued.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| issueJobId | string | | * | | ~ 1024 chars | Issue Job GRN
* Set automatically by the server |
| name | string | | ✓ | UUID | ~ 36 chars | Serial Code Issuance Job name |
| 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. |
| issuedCount | int | | | 0 | 0 ~ 1000000 | Quantity of Serial Codes issued
The number of serial codes that have been issued so far in this job. Incremented atomically as codes are created in batches. When this value reaches issueRequestCount, the job status transitions to COMPLETE. |
| issueRequestCount | int | | ✓ | | 1 ~ 100000 | Quantity of Serial Codes to issue
The total number of serial codes requested to be issued in this job. Can range from 1 to 100,000 per job. The issuance is processed asynchronously in batches. |
| status | string (enum)
enum {
"PROCESSING",
"COMPLETE"
}
| | | "PROCESSING" | | Status
The current processing status of this issuance job. Starts as PROCESSING when the job is created, and transitions to COMPLETE when all requested serial codes have been issued. Once COMPLETE, the issued serial codes can be retrieved."PROCESSING": Processing of issue / "COMPLETE": Complete / |
| createdAt | long | | * | Current time | | Creation Timestamp
Unix time, milliseconds
* Set automatically by the server |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | Revision |
**Related methods:**
describeIssueJobs - List Serial Code Issuance Jobs
getIssueJob - Get Serial Code Issuance Job
issue - Create Serial Code Issuance Job
---
### SerialKey
Serial Code
The serial code issued can be used only once.
Serial codes are issued in the format "RPCLP-FP7N-NCDMJ-FLVA-IRI4" and the data length cannot be changed.
Information on the type of campaign is also included within the serial code. When using the serial code, simply specify the Namespace in which the serial code is to be used.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| serialKeyId | string | | * | | ~ 1024 chars | Serial Key GRN
* Set automatically by the server |
| campaignModelName | string | | ✓ | | ~ 128 chars | Campaign name
The name of the campaign model this serial code belongs to. Campaign information is embedded within the serial code itself, so only the Namespace needs to be specified when using the code. |
| code | string | | ✓ | | ~ 48 chars | Serial Code
The serial code string in the format "XXXXX-XXXX-XXXXX-XXXX-XXXX". Each code is unique and includes campaign identification information. The code format and data length are fixed and cannot be changed. |
| 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. |
| status | string (enum)
enum {
"ACTIVE",
"USED",
"INACTIVE"
}
| | | "ACTIVE" | | Status
The current usage status of this serial code. Transitions from ACTIVE to USED when consumed by a user. The transition is protected by optimistic locking to prevent double-use. INACTIVE codes cannot be used."ACTIVE": Active / "USED": Already used / "INACTIVE": Disabled (cannot be used) / |
| usedUserId | string | {status} == "USED" | ✓* | | ~ 128 chars | User ID
* Required if status is "USED" |
| createdAt | long | | * | Current time | | Creation Timestamp
Unix time, milliseconds
* Set automatically by the server |
| usedAt | long | | | | | Used at
The timestamp when this serial code was consumed. Set automatically when the status transitions to USED, and cleared if the usage is reverted. |
| updatedAt | long | | * | Current time | | Last Updated Timestamp
Unix time, milliseconds
* Set automatically by the server |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | Revision |
**Related methods:**
describeSerialKeys - List Serial Codes
issueOnce - Issue a serial code
getSerialKey - Get serial code
verifyCode - Verify the validity of the serial code
verifyCodeByUserId - Verify the validity of the Serial Code by User ID
use - Use serial code
useByUserId - Use Serial Code by User ID
revertUseByUserId - Set Serial Code to Unused by User ID
---
### CampaignModel
Campaign Model
A Campaign Model is used to define and manage campaigns, linking them to serial codes.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| campaignId | string | | * | | ~ 1024 chars | GRN of the Campaign Model
* Set automatically by the server |
| name | string | | ✓ | | ~ 128 chars | Campaign Model name |
| 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. |
| enableCampaignCode | bool | | | false | | Whether to allow redemption with campaign code
When enabled, users can redeem rewards using a shared campaign code (the campaign name) instead of individual serial codes. This allows a single code to be used by multiple users. |
**Related methods:**
getSerialKey - Get serial code
verifyCode - Verify the validity of the serial code
verifyCodeByUserId - Verify the validity of the Serial Code by User ID
use - Use serial code
useByUserId - Use Serial Code by User ID
revertUseByUserId - Set Serial Code to Unused by User ID
describeCampaignModels - List Campaign Models
getCampaignModel - Get Campaign Model
---
### CurrentCampaignMaster
Currently active Campaign Model master data
This master data defines the Campaign 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-SerialKey Master Data Reference](api_reference/serial_key/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 Campaign Model Master in a format that permits master data activation
getCurrentCampaignMaster - Get currently active Campaign Model master data
updateCurrentCampaignMaster - Update currently active Campaign Model master data
updateCurrentCampaignMasterFromGitHub - Update currently active Campaign Model master data from GitHub
---
### CampaignModelMaster
Campaign Model Master Data
Campaign Model Master is data used to edit and manage Campaign Model within the game. It is temporarily stored in the Management Console's Master Data Editor.
By performing import and update processes, it is reflected as Campaign Model actually referenced by the game.
A Campaign Model is used to define and manage campaigns, linking them to serial codes.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| campaignId | string | | * | | ~ 1024 chars | Campaign Model Master Data GRN
* Set automatically by the server |
| name | string | | ✓ | | ~ 128 chars | Campaign Model name |
| 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. |
| enableCampaignCode | bool | | | false | | Whether to allow redemption with campaign code
When enabled, users can redeem rewards using a shared campaign code (the campaign name) instead of individual serial codes. This allows a single code to be used by multiple users. |
| 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:**
describeCampaignModelMasters - List Campaign Model Master
createCampaignModelMaster - Create Campaign Model Master Data
getCampaignModelMaster - Get Campaign Model Master Data
updateCampaignModelMaster - Update Campaign Model Master
deleteCampaignModelMaster - Delete Campaign 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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.DescribeNamespacesRequest;
import io.gs2.serialKey.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2SerialKey.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 serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.describe_namespaces(
serial_key.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('serial_key')
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('serial_key')
api_result_handler = client.describe_namespaces_async({
namePrefix=nil,
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### createNamespace
Create Namespace
You must specify detailed information including the name, description, and various settings of the Namespace.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| description | string | | | | ~ 1024 chars | Description |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | Transaction Setting
Configuration for controlling how transactions are processed when executing serial key operations. |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Specifies the GS2-Log Namespace for outputting API request/response logs related to serial code issuance and usage. |
#### 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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&serial_key.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
TransactionSetting: nil,
LogSetting: &serialKey.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting(null)
->withLogSetting((new \Gs2\SerialKey\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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.CreateNamespaceRequest;
import io.gs2.serialKey.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(null)
.withLogSetting(new io.gs2.serialKey.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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2SerialKey.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(null)
.WithLogSetting(new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.createNamespace(
new Gs2SerialKey.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(null)
.withLogSetting(new Gs2SerialKey.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 serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.create_namespace(
serial_key.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_transaction_setting(None)
.with_log_setting(
serial_key.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('serial_key')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
transactionSetting=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('serial_key')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
transactionSetting=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 | Namespace Status
"ACTIVE": Active / "DELETED": Deleted / |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.GetNamespaceStatusRequest;
import io.gs2.serialKey.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2SerialKey.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.get_namespace_status(
serial_key.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
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('serial_key')
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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.GetNamespaceRequest;
import io.gs2.serialKey.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.getNamespace(
new Gs2SerialKey.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.get_namespace(
serial_key.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
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('serial_key')
api_result_handler = client.get_namespace_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### updateNamespace
Update Namespace
Update the settings of the specified Namespace.
You can change the description and other settings of the Namespace.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| description | string | | | | ~ 1024 chars | Description |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | Transaction Setting
Configuration for controlling how transactions are processed when executing serial key operations. |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Specifies the GS2-Log Namespace for outputting API request/response logs related to serial code issuance and usage. |
#### 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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&serial_key.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
TransactionSetting: nil,
LogSetting: &serialKey.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting(null)
->withLogSetting((new \Gs2\SerialKey\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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.UpdateNamespaceRequest;
import io.gs2.serialKey.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(null)
.withLogSetting(new io.gs2.serialKey.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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2SerialKey.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(null)
.WithLogSetting(new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2SerialKey.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(null)
.withLogSetting(new Gs2SerialKey.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 serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.update_namespace(
serial_key.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_transaction_setting(None)
.with_log_setting(
serial_key.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('serial_key')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
transactionSetting=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('serial_key')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
transactionSetting=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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.DeleteNamespaceRequest;
import io.gs2.serialKey.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2SerialKey.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.delete_namespace(
serial_key.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
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('serial_key')
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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.GetServiceVersionRequest;
import io.gs2.serialKey.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2SerialKey.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.get_service_version(
serial_key.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
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('serial_key')
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
Return value: None
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.DumpUserDataByUserIdRequest;
import io.gs2.serialKey.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2SerialKey.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.dump_user_data_by_user_id(
serial_key.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
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('serial_key')
api_result_handler = client.dump_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### checkDumpUserDataByUserId
Check if the dump of the data associated with the specified user ID is complete
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| url | string | URL of output data |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.serialKey.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2SerialKey.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
serial_key.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('serial_key')
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('serial_key')
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
Clean User Data by User ID
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
Return value: None
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.CleanUserDataByUserIdRequest;
import io.gs2.serialKey.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2SerialKey.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.clean_user_data_by_user_id(
serial_key.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
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('serial_key')
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 clean of the data associated with the specified user ID is complete
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
Return value: None
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.serialKey.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2SerialKey.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
serial_key.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
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('serial_key')
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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.serialKey.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2SerialKey.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 serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
serial_key.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('serial_key')
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('serial_key')
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
Return value: None
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.ImportUserDataByUserIdRequest;
import io.gs2.serialKey.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2SerialKey.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.import_user_data_by_user_id(
serial_key.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('serial_key')
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('serial_key')
api_result_handler = client.import_user_data_by_user_id_async({
userId="user-0001",
uploadToken="upload-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### checkImportUserDataByUserId
Check if the import of the data associated with the specified user ID is complete
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128 chars | User ID |
| uploadToken | string | | ✓| | ~ 1024 chars | Token received in preparation for upload |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| url | string | URL of log data |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.CheckImportUserDataByUserIdRequest;
import io.gs2.serialKey.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2SerialKey.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 serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.check_import_user_data_by_user_id(
serial_key.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('serial_key')
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('serial_key')
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;
```
---
### describeIssueJobs
List Serial Code Issuance Jobs
Retrieves a paginated list of serial code issuance jobs for the specified campaign. Each job represents a batch issuance request and includes its completion status.
#### 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 (.). |
| campaignModelName | string | | ✓| | ~ 128 chars | Campaign Model name |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data acquired |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<IssueJob>](#issuejob) | List of Serial Code Issuance Jobs |
| 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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.DescribeIssueJobs(
&serial_key.DescribeIssueJobsRequest {
NamespaceName: pointy.String("namespace-0001"),
CampaignModelName: pointy.String("campaign-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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\DescribeIssueJobsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->describeIssueJobs(
(new DescribeIssueJobsRequest())
->withNamespaceName("namespace-0001")
->withCampaignModelName("campaign-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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.DescribeIssueJobsRequest;
import io.gs2.serialKey.result.DescribeIssueJobsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
DescribeIssueJobsResult result = client.describeIssueJobs(
new DescribeIssueJobsRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeIssueJobs(
new Gs2.Gs2SerialKey.Request.DescribeIssueJobsRequest()
.WithNamespaceName("namespace-0001")
.WithCampaignModelName("campaign-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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.describeIssueJobs(
new Gs2SerialKey.DescribeIssueJobsRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-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 serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.describe_issue_jobs(
serial_key.DescribeIssueJobsRequest()
.with_namespace_name('namespace-0001')
.with_campaign_model_name('campaign-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('serial_key')
api_result = client.describe_issue_jobs({
namespaceName="namespace-0001",
campaignModelName="campaign-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('serial_key')
api_result_handler = client.describe_issue_jobs_async({
namespaceName="namespace-0001",
campaignModelName="campaign-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;
```
---
### getIssueJob
Get Serial Code Issuance Job
Retrieves the specified serial code issuance job including its name, request count, metadata, and completion status.
#### 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 (.). |
| campaignModelName | string | | ✓| | ~ 128 chars | Campaign Model name |
| issueJobName | string | | ✓| UUID | ~ 36 chars | Serial Code Issuance Job name |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [IssueJob](#issuejob) | Serial Code Issuance Job |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.GetIssueJob(
&serial_key.GetIssueJobRequest {
NamespaceName: pointy.String("namespace-0001"),
CampaignModelName: pointy.String("campaign-0001"),
IssueJobName: pointy.String("campaign-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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\GetIssueJobRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->getIssueJob(
(new GetIssueJobRequest())
->withNamespaceName("namespace-0001")
->withCampaignModelName("campaign-0001")
->withIssueJobName("campaign-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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.GetIssueJobRequest;
import io.gs2.serialKey.result.GetIssueJobResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
GetIssueJobResult result = client.getIssueJob(
new GetIssueJobRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withIssueJobName("campaign-0001")
);
IssueJob 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetIssueJob(
new Gs2.Gs2SerialKey.Request.GetIssueJobRequest()
.WithNamespaceName("namespace-0001")
.WithCampaignModelName("campaign-0001")
.WithIssueJobName("campaign-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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.getIssueJob(
new Gs2SerialKey.GetIssueJobRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withIssueJobName("campaign-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.get_issue_job(
serial_key.GetIssueJobRequest()
.with_namespace_name('namespace-0001')
.with_campaign_model_name('campaign-0001')
.with_issue_job_name('campaign-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.get_issue_job({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
issueJobName="campaign-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('serial_key')
api_result_handler = client.get_issue_job_async({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
issueJobName="campaign-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;
```
---
### issue
Create Serial Code Issuance Job
Initiates an asynchronous serial code generation job. The codes are generated in batches and a summary file is created upon completion.
#### 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 (.). |
| campaignModelName | string | | ✓| | ~ 128 chars | Campaign Model name |
| 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. |
| issueRequestCount | int | | ✓| | 1 ~ 100000 | Quantity of Serial Codes to issue
The total number of serial codes requested to be issued in this job. Can range from 1 to 100,000 per job. The issuance is processed asynchronously in batches. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [IssueJob](#issuejob) | Serial Code Issuance Job |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.Issue(
&serial_key.IssueRequest {
NamespaceName: pointy.String("namespace-0001"),
CampaignModelName: pointy.String("campaign-0001"),
Metadata: nil,
IssueRequestCount: pointy.Int32(30),
}
)
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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\IssueRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->issue(
(new IssueRequest())
->withNamespaceName("namespace-0001")
->withCampaignModelName("campaign-0001")
->withMetadata(null)
->withIssueRequestCount(30)
);
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.IssueRequest;
import io.gs2.serialKey.result.IssueResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
IssueResult result = client.issue(
new IssueRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withMetadata(null)
.withIssueRequestCount(30)
);
IssueJob 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.Issue(
new Gs2.Gs2SerialKey.Request.IssueRequest()
.WithNamespaceName("namespace-0001")
.WithCampaignModelName("campaign-0001")
.WithMetadata(null)
.WithIssueRequestCount(30),
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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.issue(
new Gs2SerialKey.IssueRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withMetadata(null)
.withIssueRequestCount(30)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.issue(
serial_key.IssueRequest()
.with_namespace_name('namespace-0001')
.with_campaign_model_name('campaign-0001')
.with_metadata(None)
.with_issue_request_count(30)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.issue({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
metadata=nil,
issueRequestCount=30,
})
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('serial_key')
api_result_handler = client.issue_async({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
metadata=nil,
issueRequestCount=30,
})
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;
```
---
### describeSerialKeys
List Serial Codes
Retrieves a paginated list of serial codes generated by a completed issuance job. The codes are loaded in parallel for efficient retrieval and paginated through an in-memory buffer.
#### 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 (.). |
| campaignModelName | string | | ✓| | ~ 128 chars | Campaign Model name |
| issueJobName | string | | ✓| UUID | ~ 36 chars | Serial Code Issuance Job name |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data acquired |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<SerialKey>](#serialkey) | List of Serial Code |
| 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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.DescribeSerialKeys(
&serial_key.DescribeSerialKeysRequest {
NamespaceName: pointy.String("namespace-0001"),
CampaignModelName: pointy.String("campaign-0001"),
IssueJobName: pointy.String("job-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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\DescribeSerialKeysRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->describeSerialKeys(
(new DescribeSerialKeysRequest())
->withNamespaceName("namespace-0001")
->withCampaignModelName("campaign-0001")
->withIssueJobName("job-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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.DescribeSerialKeysRequest;
import io.gs2.serialKey.result.DescribeSerialKeysResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
DescribeSerialKeysResult result = client.describeSerialKeys(
new DescribeSerialKeysRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withIssueJobName("job-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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSerialKeys(
new Gs2.Gs2SerialKey.Request.DescribeSerialKeysRequest()
.WithNamespaceName("namespace-0001")
.WithCampaignModelName("campaign-0001")
.WithIssueJobName("job-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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.describeSerialKeys(
new Gs2SerialKey.DescribeSerialKeysRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withIssueJobName("job-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 serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.describe_serial_keys(
serial_key.DescribeSerialKeysRequest()
.with_namespace_name('namespace-0001')
.with_campaign_model_name('campaign-0001')
.with_issue_job_name('job-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('serial_key')
api_result = client.describe_serial_keys({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
issueJobName="job-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('serial_key')
api_result_handler = client.describe_serial_keys_async({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
issueJobName="job-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;
```
---
### downloadSerialCodes
Download Serial Codes as a File
Generates a pre-signed URL to download all serial codes from a completed issuance job as a file. This is suitable for bulk export of serial codes.
#### 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 (.). |
| campaignModelName | string | | ✓| | ~ 128 chars | Campaign Model name |
| issueJobName | string | | ✓| UUID | ~ 36 chars | Serial Code Issuance Job name |
#### Result
| | Type | Description |
| --- | --- | --- |
| url | string | URL of file |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.DownloadSerialCodes(
&serial_key.DownloadSerialCodesRequest {
NamespaceName: pointy.String("namespace-0001"),
CampaignModelName: pointy.String("campaign-0001"),
IssueJobName: pointy.String("job-0001"),
}
)
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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\DownloadSerialCodesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->downloadSerialCodes(
(new DownloadSerialCodesRequest())
->withNamespaceName("namespace-0001")
->withCampaignModelName("campaign-0001")
->withIssueJobName("job-0001")
);
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.DownloadSerialCodesRequest;
import io.gs2.serialKey.result.DownloadSerialCodesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
DownloadSerialCodesResult result = client.downloadSerialCodes(
new DownloadSerialCodesRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withIssueJobName("job-0001")
);
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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.DownloadSerialCodes(
new Gs2.Gs2SerialKey.Request.DownloadSerialCodesRequest()
.WithNamespaceName("namespace-0001")
.WithCampaignModelName("campaign-0001")
.WithIssueJobName("job-0001"),
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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.downloadSerialCodes(
new Gs2SerialKey.DownloadSerialCodesRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withIssueJobName("job-0001")
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.download_serial_codes(
serial_key.DownloadSerialCodesRequest()
.with_namespace_name('namespace-0001')
.with_campaign_model_name('campaign-0001')
.with_issue_job_name('job-0001')
)
url = result.url
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.download_serial_codes({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
issueJobName="job-0001",
})
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('serial_key')
api_result_handler = client.download_serial_codes_async({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
issueJobName="job-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
url = result.url;
```
---
### issueOnce
Issue a serial code
Issues a single serial code immediately. The code is generated using AES encryption and base32 encoding in the format XXXXX-XXXX-XXXXX-XXXX-XXXXX. Unlike batch issuance jobs, this generates and returns a code synchronously.
#### 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 (.). |
| campaignModelName | string | | ✓| | ~ 128 chars | Campaign Model name |
| 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. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [SerialKey](#serialkey) | Serial Code |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.IssueOnce(
&serial_key.IssueOnceRequest {
NamespaceName: pointy.String("namespace-0001"),
CampaignModelName: pointy.String("campaign-0001"),
Metadata: 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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\IssueOnceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->issueOnce(
(new IssueOnceRequest())
->withNamespaceName("namespace-0001")
->withCampaignModelName("campaign-0001")
->withMetadata(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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.IssueOnceRequest;
import io.gs2.serialKey.result.IssueOnceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
IssueOnceResult result = client.issueOnce(
new IssueOnceRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withMetadata(null)
);
SerialKey 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.IssueOnce(
new Gs2.Gs2SerialKey.Request.IssueOnceRequest()
.WithNamespaceName("namespace-0001")
.WithCampaignModelName("campaign-0001")
.WithMetadata(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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.issueOnce(
new Gs2SerialKey.IssueOnceRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withMetadata(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.issue_once(
serial_key.IssueOnceRequest()
.with_namespace_name('namespace-0001')
.with_campaign_model_name('campaign-0001')
.with_metadata(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.issue_once({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
metadata=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('serial_key')
api_result_handler = client.issue_once_async({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
metadata=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;
```
---
### getSerialKey
Get serial code
Retrieves the specified serial code along with its associated campaign model. Returns the code's usage status and metadata.
#### 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 (.). |
| code | string | | ✓| | ~ 48 chars | Serial Code
The serial code string in the format "XXXXX-XXXX-XXXXX-XXXX-XXXX". Each code is unique and includes campaign identification information. The code format and data length are fixed and cannot be changed. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [SerialKey](#serialkey) | Serial Code |
| campaignModel | [CampaignModel](#campaignmodel) | Campaign Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.GetSerialKey(
&serial_key.GetSerialKeyRequest {
NamespaceName: pointy.String("namespace-0001"),
Code: pointy.String("code-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
campaignModel := result.CampaignModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\GetSerialKeyRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->getSerialKey(
(new GetSerialKeyRequest())
->withNamespaceName("namespace-0001")
->withCode("code-0001")
);
$item = $result->getItem();
$campaignModel = $result->getCampaignModel();
} 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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.GetSerialKeyRequest;
import io.gs2.serialKey.result.GetSerialKeyResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
GetSerialKeyResult result = client.getSerialKey(
new GetSerialKeyRequest()
.withNamespaceName("namespace-0001")
.withCode("code-0001")
);
SerialKey item = result.getItem();
CampaignModel campaignModel = result.getCampaignModel();
} 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSerialKey(
new Gs2.Gs2SerialKey.Request.GetSerialKeyRequest()
.WithNamespaceName("namespace-0001")
.WithCode("code-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var campaignModel = result.CampaignModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.getSerialKey(
new Gs2SerialKey.GetSerialKeyRequest()
.withNamespaceName("namespace-0001")
.withCode("code-0001")
);
const item = result.getItem();
const campaignModel = result.getCampaignModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.get_serial_key(
serial_key.GetSerialKeyRequest()
.with_namespace_name('namespace-0001')
.with_code('code-0001')
)
item = result.item
campaign_model = result.campaign_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.get_serial_key({
namespaceName="namespace-0001",
code="code-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
campaignModel = result.campaignModel;
```
**GS2-Script(Async)**
```lua
client = gs2('serial_key')
api_result_handler = client.get_serial_key_async({
namespaceName="namespace-0001",
code="code-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;
campaignModel = result.campaignModel;
```
---
### verifyCode
Verify the validity of the serial code
Verifies a serial code without consuming it. Supports verification against a specific campaign model name, and can check whether the code is active (unused) or inactive (already used).
#### 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 |
| code | string | | ✓| | ~ 48 chars | Serial Code
The serial code string in the format "XXXXX-XXXX-XXXXX-XXXX-XXXX". Each code is unique and includes campaign identification information. The code format and data length are fixed and cannot be changed. |
| campaignModelName | string | | | | ~ 128 chars | Campaign name
The name of the campaign model this serial code belongs to. Campaign information is embedded within the serial code itself, so only the Namespace needs to be specified when using the code. |
| verifyType | string (enum)
enum {
"active",
"inactive"
}
| | ✓| | | Verification type"active": Active / "inactive": Inactive / |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [SerialKey](#serialkey) | Serial Code |
| campaignModel | [CampaignModel](#campaignmodel) | Campaign Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.VerifyCode(
&serial_key.VerifyCodeRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
Code: pointy.String("code-0001"),
CampaignModelName: nil,
VerifyType: pointy.String("inactive"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
campaignModel := result.CampaignModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\VerifyCodeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->verifyCode(
(new VerifyCodeRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withCode("code-0001")
->withCampaignModelName(null)
->withVerifyType("inactive")
);
$item = $result->getItem();
$campaignModel = $result->getCampaignModel();
} 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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.VerifyCodeRequest;
import io.gs2.serialKey.result.VerifyCodeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
VerifyCodeResult result = client.verifyCode(
new VerifyCodeRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCode("code-0001")
.withCampaignModelName(null)
.withVerifyType("inactive")
);
SerialKey item = result.getItem();
CampaignModel campaignModel = result.getCampaignModel();
} 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.VerifyCode(
new Gs2.Gs2SerialKey.Request.VerifyCodeRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithCode("code-0001")
.WithCampaignModelName(null)
.WithVerifyType("inactive"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var campaignModel = result.CampaignModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.verifyCode(
new Gs2SerialKey.VerifyCodeRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCode("code-0001")
.withCampaignModelName(null)
.withVerifyType("inactive")
);
const item = result.getItem();
const campaignModel = result.getCampaignModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.verify_code(
serial_key.VerifyCodeRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_code('code-0001')
.with_campaign_model_name(None)
.with_verify_type('inactive')
)
item = result.item
campaign_model = result.campaign_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.verify_code({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
code="code-0001",
campaignModelName=nil,
verifyType="inactive",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
campaignModel = result.campaignModel;
```
**GS2-Script(Async)**
```lua
client = gs2('serial_key')
api_result_handler = client.verify_code_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
code="code-0001",
campaignModelName=nil,
verifyType="inactive",
})
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;
campaignModel = result.campaignModel;
```
---
### verifyCodeByUserId
Verify the validity of the Serial Code by User ID
Verifies a serial code for the specified user without consuming it. Supports verification against a specific campaign model name, and can check whether the code is active (unused) or inactive (already used).
#### 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 |
| code | string | | ✓| | ~ 48 chars | Serial Code
The serial code string in the format "XXXXX-XXXX-XXXXX-XXXX-XXXX". Each code is unique and includes campaign identification information. The code format and data length are fixed and cannot be changed. |
| campaignModelName | string | | | | ~ 128 chars | Campaign name
The name of the campaign model this serial code belongs to. Campaign information is embedded within the serial code itself, so only the Namespace needs to be specified when using the code. |
| verifyType | string (enum)
enum {
"active",
"inactive"
}
| | ✓| | | Verification type"active": Active / "inactive": Inactive / |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [SerialKey](#serialkey) | Serial Code |
| campaignModel | [CampaignModel](#campaignmodel) | Campaign Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.VerifyCodeByUserId(
&serial_key.VerifyCodeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
Code: pointy.String("code-0001"),
CampaignModelName: nil,
VerifyType: pointy.String("inactive"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
campaignModel := result.CampaignModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\VerifyCodeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->verifyCodeByUserId(
(new VerifyCodeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withCode("code-0001")
->withCampaignModelName(null)
->withVerifyType("inactive")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$campaignModel = $result->getCampaignModel();
} 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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.VerifyCodeByUserIdRequest;
import io.gs2.serialKey.result.VerifyCodeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
VerifyCodeByUserIdResult result = client.verifyCodeByUserId(
new VerifyCodeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCode("code-0001")
.withCampaignModelName(null)
.withVerifyType("inactive")
.withTimeOffsetToken(null)
);
SerialKey item = result.getItem();
CampaignModel campaignModel = result.getCampaignModel();
} 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.VerifyCodeByUserId(
new Gs2.Gs2SerialKey.Request.VerifyCodeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithCode("code-0001")
.WithCampaignModelName(null)
.WithVerifyType("inactive")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var campaignModel = result.CampaignModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.verifyCodeByUserId(
new Gs2SerialKey.VerifyCodeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCode("code-0001")
.withCampaignModelName(null)
.withVerifyType("inactive")
.withTimeOffsetToken(null)
);
const item = result.getItem();
const campaignModel = result.getCampaignModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.verify_code_by_user_id(
serial_key.VerifyCodeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_code('code-0001')
.with_campaign_model_name(None)
.with_verify_type('inactive')
.with_time_offset_token(None)
)
item = result.item
campaign_model = result.campaign_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.verify_code_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
code="code-0001",
campaignModelName=nil,
verifyType="inactive",
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;
campaignModel = result.campaignModel;
```
**GS2-Script(Async)**
```lua
client = gs2('serial_key')
api_result_handler = client.verify_code_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
code="code-0001",
campaignModelName=nil,
verifyType="inactive",
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;
campaignModel = result.campaignModel;
```
---
### use
Use serial code
Marks a serial code as used by the current user. Validates that the code exists and has not already been used. Returns an error if the code is not found or has already been consumed.
#### 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 |
| code | string | | ✓| | ~ 48 chars | Serial Code
The serial code string in the format "XXXXX-XXXX-XXXXX-XXXX-XXXX". Each code is unique and includes campaign identification information. The code format and data length are fixed and cannot be changed. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [SerialKey](#serialkey) | Serial Code |
| campaignModel | [CampaignModel](#campaignmodel) | Campaign Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.Use(
&serial_key.UseRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
Code: pointy.String("code-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
campaignModel := result.CampaignModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\UseRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->use(
(new UseRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withCode("code-0001")
);
$item = $result->getItem();
$campaignModel = $result->getCampaignModel();
} 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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.UseRequest;
import io.gs2.serialKey.result.UseResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
UseResult result = client.use(
new UseRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCode("code-0001")
);
SerialKey item = result.getItem();
CampaignModel campaignModel = result.getCampaignModel();
} 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.Use(
new Gs2.Gs2SerialKey.Request.UseRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithCode("code-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var campaignModel = result.CampaignModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.use(
new Gs2SerialKey.UseRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withCode("code-0001")
);
const item = result.getItem();
const campaignModel = result.getCampaignModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.use(
serial_key.UseRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_code('code-0001')
)
item = result.item
campaign_model = result.campaign_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.use({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
code="code-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
campaignModel = result.campaignModel;
```
**GS2-Script(Async)**
```lua
client = gs2('serial_key')
api_result_handler = client.use_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
code="code-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;
campaignModel = result.campaignModel;
```
---
### useByUserId
Use Serial Code by User ID
Marks a serial code as used by the specified user. Validates that the code exists and has not already been used.
#### 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 |
| code | string | | ✓| | ~ 48 chars | Serial Code
The serial code string in the format "XXXXX-XXXX-XXXXX-XXXX-XXXX". Each code is unique and includes campaign identification information. The code format and data length are fixed and cannot be changed. |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [SerialKey](#serialkey) | Serial Code |
| campaignModel | [CampaignModel](#campaignmodel) | Campaign Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.UseByUserId(
&serial_key.UseByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
Code: pointy.String("code-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
campaignModel := result.CampaignModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\UseByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->useByUserId(
(new UseByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withCode("code-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$campaignModel = $result->getCampaignModel();
} 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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.UseByUserIdRequest;
import io.gs2.serialKey.result.UseByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
UseByUserIdResult result = client.useByUserId(
new UseByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCode("code-0001")
.withTimeOffsetToken(null)
);
SerialKey item = result.getItem();
CampaignModel campaignModel = result.getCampaignModel();
} 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.UseByUserId(
new Gs2.Gs2SerialKey.Request.UseByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithCode("code-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var campaignModel = result.CampaignModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.useByUserId(
new Gs2SerialKey.UseByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCode("code-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
const campaignModel = result.getCampaignModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.use_by_user_id(
serial_key.UseByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_code('code-0001')
.with_time_offset_token(None)
)
item = result.item
campaign_model = result.campaign_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.use_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
code="code-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;
campaignModel = result.campaignModel;
```
**GS2-Script(Async)**
```lua
client = gs2('serial_key')
api_result_handler = client.use_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
code="code-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;
campaignModel = result.campaignModel;
```
---
### revertUseByUserId
Set Serial Code to Unused by User ID
Reverts a used serial code back to unused status. Validates that the code is currently in used state before reverting.
#### 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 |
| code | string | | ✓| | ~ 48 chars | Serial Code
The serial code string in the format "XXXXX-XXXX-XXXXX-XXXX-XXXX". Each code is unique and includes campaign identification information. The code format and data length are fixed and cannot be changed. |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [SerialKey](#serialkey) | Serial Code |
| campaignModel | [CampaignModel](#campaignmodel) | Campaign Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.RevertUseByUserId(
&serial_key.RevertUseByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
Code: pointy.String("code-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
campaignModel := result.CampaignModel
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\RevertUseByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->revertUseByUserId(
(new RevertUseByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withCode("code-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$campaignModel = $result->getCampaignModel();
} 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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.RevertUseByUserIdRequest;
import io.gs2.serialKey.result.RevertUseByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
RevertUseByUserIdResult result = client.revertUseByUserId(
new RevertUseByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCode("code-0001")
.withTimeOffsetToken(null)
);
SerialKey item = result.getItem();
CampaignModel campaignModel = result.getCampaignModel();
} 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.RevertUseByUserId(
new Gs2.Gs2SerialKey.Request.RevertUseByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithCode("code-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var campaignModel = result.CampaignModel;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.revertUseByUserId(
new Gs2SerialKey.RevertUseByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withCode("code-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
const campaignModel = result.getCampaignModel();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.revert_use_by_user_id(
serial_key.RevertUseByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_code('code-0001')
.with_time_offset_token(None)
)
item = result.item
campaign_model = result.campaign_model
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.revert_use_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
code="code-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;
campaignModel = result.campaignModel;
```
**GS2-Script(Async)**
```lua
client = gs2('serial_key')
api_result_handler = client.revert_use_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
code="code-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;
campaignModel = result.campaignModel;
```
---
### describeCampaignModels
List Campaign Models
Retrieves the list of currently active campaign models in the Namespace. Campaign models define the serial code campaign configuration including whether campaign codes are enabled.
#### 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<CampaignModel>](#campaignmodel) | List of Campaign Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.DescribeCampaignModels(
&serial_key.DescribeCampaignModelsRequest {
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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\DescribeCampaignModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->describeCampaignModels(
(new DescribeCampaignModelsRequest())
->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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.DescribeCampaignModelsRequest;
import io.gs2.serialKey.result.DescribeCampaignModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
DescribeCampaignModelsResult result = client.describeCampaignModels(
new DescribeCampaignModelsRequest()
.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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCampaignModels(
new Gs2.Gs2SerialKey.Request.DescribeCampaignModelsRequest()
.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.describeCampaignModels(
new Gs2SerialKey.DescribeCampaignModelsRequest()
.withNamespaceName("namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.describe_campaign_models(
serial_key.DescribeCampaignModelsRequest()
.with_namespace_name('namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.describe_campaign_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('serial_key')
api_result_handler = client.describe_campaign_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;
```
---
### getCampaignModel
Get Campaign Model
Retrieves the specified campaign model including its name, metadata, and campaign code enablement setting.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| campaignModelName | string | | ✓| | ~ 128 chars | Campaign Model name |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CampaignModel](#campaignmodel) | Campaign Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.GetCampaignModel(
&serial_key.GetCampaignModelRequest {
NamespaceName: pointy.String("namespace-0001"),
CampaignModelName: pointy.String("campaign-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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\GetCampaignModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->getCampaignModel(
(new GetCampaignModelRequest())
->withNamespaceName("namespace-0001")
->withCampaignModelName("campaign-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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.GetCampaignModelRequest;
import io.gs2.serialKey.result.GetCampaignModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
GetCampaignModelResult result = client.getCampaignModel(
new GetCampaignModelRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
);
CampaignModel 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCampaignModel(
new Gs2.Gs2SerialKey.Request.GetCampaignModelRequest()
.WithNamespaceName("namespace-0001")
.WithCampaignModelName("campaign-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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.getCampaignModel(
new Gs2SerialKey.GetCampaignModelRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.get_campaign_model(
serial_key.GetCampaignModelRequest()
.with_namespace_name('namespace-0001')
.with_campaign_model_name('campaign-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.get_campaign_model({
namespaceName="namespace-0001",
campaignModelName="campaign-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('serial_key')
api_result_handler = client.get_campaign_model_async({
namespaceName="namespace-0001",
campaignModelName="campaign-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 Campaign Model Master in a format that permits master data activation
Exports the currently registered campaign model masters in an activatable master data format. The exported data contains all campaign definitions including campaign code enablement settings.
#### 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 | [CurrentCampaignMaster](#currentcampaignmaster) | Campaign 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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.ExportMaster(
&serial_key.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\ExportMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.ExportMasterRequest;
import io.gs2.serialKey.result.ExportMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
ExportMasterResult result = client.exportMaster(
new ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentCampaignMaster 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExportMaster(
new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.exportMaster(
new Gs2SerialKey.ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.export_master(
serial_key.ExportMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
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('serial_key')
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;
```
---
### getCurrentCampaignMaster
Get currently active Campaign Model master data
Retrieves the currently active campaign model master data including all campaign definitions that are being used for serial code management.
#### 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 | [CurrentCampaignMaster](#currentcampaignmaster) | Currently active Campaign Model master data |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.GetCurrentCampaignMaster(
&serial_key.GetCurrentCampaignMasterRequest {
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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\GetCurrentCampaignMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->getCurrentCampaignMaster(
(new GetCurrentCampaignMasterRequest())
->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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.GetCurrentCampaignMasterRequest;
import io.gs2.serialKey.result.GetCurrentCampaignMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
GetCurrentCampaignMasterResult result = client.getCurrentCampaignMaster(
new GetCurrentCampaignMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentCampaignMaster 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCurrentCampaignMaster(
new Gs2.Gs2SerialKey.Request.GetCurrentCampaignMasterRequest()
.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.getCurrentCampaignMaster(
new Gs2SerialKey.GetCurrentCampaignMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.get_current_campaign_master(
serial_key.GetCurrentCampaignMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.get_current_campaign_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('serial_key')
api_result_handler = client.get_current_campaign_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;
```
---
### preUpdateCurrentCampaignMaster
Update currently active Campaign 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 UpdateCurrentCampaignMaster 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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.PreUpdateCurrentCampaignMaster(
&serial_key.PreUpdateCurrentCampaignMasterRequest {
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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\PreUpdateCurrentCampaignMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->preUpdateCurrentCampaignMaster(
(new PreUpdateCurrentCampaignMasterRequest())
->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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.PreUpdateCurrentCampaignMasterRequest;
import io.gs2.serialKey.result.PreUpdateCurrentCampaignMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
PreUpdateCurrentCampaignMasterResult result = client.preUpdateCurrentCampaignMaster(
new PreUpdateCurrentCampaignMasterRequest()
.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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.PreUpdateCurrentCampaignMaster(
new Gs2.Gs2SerialKey.Request.PreUpdateCurrentCampaignMasterRequest()
.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.preUpdateCurrentCampaignMaster(
new Gs2SerialKey.PreUpdateCurrentCampaignMasterRequest()
.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 serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.pre_update_current_campaign_master(
serial_key.PreUpdateCurrentCampaignMasterRequest()
.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('serial_key')
api_result = client.pre_update_current_campaign_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('serial_key')
api_result_handler = client.pre_update_current_campaign_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;
```
---
### updateCurrentCampaignMaster
Update currently active Campaign Model master data
Updates the currently active campaign model master data. Supports both direct update mode and pre-upload mode for handling large master data. In pre-upload mode, the settings are read using the upload token obtained from the PreUpdate API.
#### 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 the 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 | [CurrentCampaignMaster](#currentcampaignmaster) | Updated master data of the currently active Campaign Models |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.UpdateCurrentCampaignMaster(
&serial_key.UpdateCurrentCampaignMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Mode: pointy.String("direct"),
Settings: pointy.String("{\"version\": \"2022-09-13\", \"campaignModels\": [{\"name\": \"campaign-0001\", \"metadata\": \"CAMPAIGN_0001\", \"enableCampaignCode\": true}]}"),
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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\UpdateCurrentCampaignMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->updateCurrentCampaignMaster(
(new UpdateCurrentCampaignMasterRequest())
->withNamespaceName("namespace-0001")
->withMode("direct")
->withSettings("{\"version\": \"2022-09-13\", \"campaignModels\": [{\"name\": \"campaign-0001\", \"metadata\": \"CAMPAIGN_0001\", \"enableCampaignCode\": true}]}")
->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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.UpdateCurrentCampaignMasterRequest;
import io.gs2.serialKey.result.UpdateCurrentCampaignMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
UpdateCurrentCampaignMasterResult result = client.updateCurrentCampaignMaster(
new UpdateCurrentCampaignMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\"version\": \"2022-09-13\", \"campaignModels\": [{\"name\": \"campaign-0001\", \"metadata\": \"CAMPAIGN_0001\", \"enableCampaignCode\": true}]}")
.withUploadToken(null)
);
CurrentCampaignMaster 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentCampaignMaster(
new Gs2.Gs2SerialKey.Request.UpdateCurrentCampaignMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMode("direct")
.WithSettings("{\"version\": \"2022-09-13\", \"campaignModels\": [{\"name\": \"campaign-0001\", \"metadata\": \"CAMPAIGN_0001\", \"enableCampaignCode\": true}]}")
.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.updateCurrentCampaignMaster(
new Gs2SerialKey.UpdateCurrentCampaignMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\"version\": \"2022-09-13\", \"campaignModels\": [{\"name\": \"campaign-0001\", \"metadata\": \"CAMPAIGN_0001\", \"enableCampaignCode\": true}]}")
.withUploadToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.update_current_campaign_master(
serial_key.UpdateCurrentCampaignMasterRequest()
.with_namespace_name('namespace-0001')
.with_mode('direct')
.with_settings('{"version": "2022-09-13", "campaignModels": [{"name": "campaign-0001", "metadata": "CAMPAIGN_0001", "enableCampaignCode": true}]}')
.with_upload_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.update_current_campaign_master({
namespaceName="namespace-0001",
mode="direct",
settings="{\"version\": \"2022-09-13\", \"campaignModels\": [{\"name\": \"campaign-0001\", \"metadata\": \"CAMPAIGN_0001\", \"enableCampaignCode\": true}]}",
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('serial_key')
api_result_handler = client.update_current_campaign_master_async({
namespaceName="namespace-0001",
mode="direct",
settings="{\"version\": \"2022-09-13\", \"campaignModels\": [{\"name\": \"campaign-0001\", \"metadata\": \"CAMPAIGN_0001\", \"enableCampaignCode\": true}]}",
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;
```
---
### updateCurrentCampaignMasterFromGitHub
Update currently active Campaign Model master data from GitHub
Updates the currently active campaign model master data by checking out master data from a GitHub repository using the specified checkout settings. The API key is decrypted via the key service to authenticate with GitHub.
#### 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 | [CurrentCampaignMaster](#currentcampaignmaster) | Updated master data of the currently active Campaign Models |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.UpdateCurrentCampaignMasterFromGitHub(
&serial_key.UpdateCurrentCampaignMasterFromGitHubRequest {
NamespaceName: pointy.String("namespace-0001"),
CheckoutSetting: &serialKey.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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\UpdateCurrentCampaignMasterFromGitHubRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->updateCurrentCampaignMasterFromGitHub(
(new UpdateCurrentCampaignMasterFromGitHubRequest())
->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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.UpdateCurrentCampaignMasterFromGitHubRequest;
import io.gs2.serialKey.result.UpdateCurrentCampaignMasterFromGitHubResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
UpdateCurrentCampaignMasterFromGitHubResult result = client.updateCurrentCampaignMasterFromGitHub(
new UpdateCurrentCampaignMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
CurrentCampaignMaster 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentCampaignMasterFromGitHub(
new Gs2.Gs2SerialKey.Request.UpdateCurrentCampaignMasterFromGitHubRequest()
.WithNamespaceName("namespace-0001")
.WithCheckoutSetting(new Gs2.Gs2SerialKey.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.updateCurrentCampaignMasterFromGitHub(
new Gs2SerialKey.UpdateCurrentCampaignMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new Gs2SerialKey.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 serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.update_current_campaign_master_from_git_hub(
serial_key.UpdateCurrentCampaignMasterFromGitHubRequest()
.with_namespace_name('namespace-0001')
.with_checkout_setting(serial_key.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('serial_key')
api_result = client.update_current_campaign_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('serial_key')
api_result_handler = client.update_current_campaign_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;
```
---
### describeCampaignModelMasters
List Campaign Model Master
Retrieves a paginated list of campaign model masters. Can filter by name prefix. Campaign model masters define serial code campaign configurations including campaign code enablement.
#### 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 Campaign Model name prefix |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data acquired |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<CampaignModelMaster>](#campaignmodelmaster) | List of Campaign 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/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.DescribeCampaignModelMasters(
&serial_key.DescribeCampaignModelMastersRequest {
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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\DescribeCampaignModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->describeCampaignModelMasters(
(new DescribeCampaignModelMastersRequest())
->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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.DescribeCampaignModelMastersRequest;
import io.gs2.serialKey.result.DescribeCampaignModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
DescribeCampaignModelMastersResult result = client.describeCampaignModelMasters(
new DescribeCampaignModelMastersRequest()
.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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCampaignModelMasters(
new Gs2.Gs2SerialKey.Request.DescribeCampaignModelMastersRequest()
.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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.describeCampaignModelMasters(
new Gs2SerialKey.DescribeCampaignModelMastersRequest()
.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 serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.describe_campaign_model_masters(
serial_key.DescribeCampaignModelMastersRequest()
.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('serial_key')
api_result = client.describe_campaign_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('serial_key')
api_result_handler = client.describe_campaign_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;
```
---
### createCampaignModelMaster
Create Campaign Model Master Data
Creates a new campaign model master with a name, description, metadata, and the enableCampaignCode flag that controls whether campaign codes can be used with this campaign.
#### 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 | Campaign Model name |
| 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. |
| enableCampaignCode | bool | | | false | | Whether to allow redemption with campaign code
When enabled, users can redeem rewards using a shared campaign code (the campaign name) instead of individual serial codes. This allows a single code to be used by multiple users. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CampaignModelMaster](#campaignmodelmaster) | Created Campaign Model Master Data |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.CreateCampaignModelMaster(
&serial_key.CreateCampaignModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("campaign-0001"),
Description: nil,
Metadata: nil,
EnableCampaignCode: 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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\CreateCampaignModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->createCampaignModelMaster(
(new CreateCampaignModelMasterRequest())
->withNamespaceName("namespace-0001")
->withName("campaign-0001")
->withDescription(null)
->withMetadata(null)
->withEnableCampaignCode(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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.CreateCampaignModelMasterRequest;
import io.gs2.serialKey.result.CreateCampaignModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
CreateCampaignModelMasterResult result = client.createCampaignModelMaster(
new CreateCampaignModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("campaign-0001")
.withDescription(null)
.withMetadata(null)
.withEnableCampaignCode(null)
);
CampaignModelMaster 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateCampaignModelMaster(
new Gs2.Gs2SerialKey.Request.CreateCampaignModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("campaign-0001")
.WithDescription(null)
.WithMetadata(null)
.WithEnableCampaignCode(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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.createCampaignModelMaster(
new Gs2SerialKey.CreateCampaignModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("campaign-0001")
.withDescription(null)
.withMetadata(null)
.withEnableCampaignCode(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.create_campaign_model_master(
serial_key.CreateCampaignModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('campaign-0001')
.with_description(None)
.with_metadata(None)
.with_enable_campaign_code(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.create_campaign_model_master({
namespaceName="namespace-0001",
name="campaign-0001",
description=nil,
metadata=nil,
enableCampaignCode=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('serial_key')
api_result_handler = client.create_campaign_model_master_async({
namespaceName="namespace-0001",
name="campaign-0001",
description=nil,
metadata=nil,
enableCampaignCode=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;
```
---
### getCampaignModelMaster
Get Campaign Model Master Data
Retrieves the specified campaign model master including its name, description, metadata, and campaign code enablement setting.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| campaignModelName | string | | ✓| | ~ 128 chars | Campaign Model name |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CampaignModelMaster](#campaignmodelmaster) | Campaign Model Master Data |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.GetCampaignModelMaster(
&serial_key.GetCampaignModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CampaignModelName: pointy.String("campaign-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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\GetCampaignModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->getCampaignModelMaster(
(new GetCampaignModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCampaignModelName("campaign-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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.GetCampaignModelMasterRequest;
import io.gs2.serialKey.result.GetCampaignModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
GetCampaignModelMasterResult result = client.getCampaignModelMaster(
new GetCampaignModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
);
CampaignModelMaster 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCampaignModelMaster(
new Gs2.Gs2SerialKey.Request.GetCampaignModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCampaignModelName("campaign-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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.getCampaignModelMaster(
new Gs2SerialKey.GetCampaignModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.get_campaign_model_master(
serial_key.GetCampaignModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_campaign_model_name('campaign-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.get_campaign_model_master({
namespaceName="namespace-0001",
campaignModelName="campaign-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('serial_key')
api_result_handler = client.get_campaign_model_master_async({
namespaceName="namespace-0001",
campaignModelName="campaign-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;
```
---
### updateCampaignModelMaster
Update Campaign Model Master
Updates the specified campaign model master's description, metadata, and campaign code enablement setting.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| campaignModelName | string | | ✓| | ~ 128 chars | Campaign Model name |
| 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. |
| enableCampaignCode | bool | | | false | | Whether to allow redemption with campaign code
When enabled, users can redeem rewards using a shared campaign code (the campaign name) instead of individual serial codes. This allows a single code to be used by multiple users. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CampaignModelMaster](#campaignmodelmaster) | Campaign Model Master updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.UpdateCampaignModelMaster(
&serial_key.UpdateCampaignModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CampaignModelName: pointy.String("campaign-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("{\"hoge\": \"fuga\"}"),
EnableCampaignCode: 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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\UpdateCampaignModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->updateCampaignModelMaster(
(new UpdateCampaignModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCampaignModelName("campaign-0001")
->withDescription("description1")
->withMetadata("{\"hoge\": \"fuga\"}")
->withEnableCampaignCode(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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.UpdateCampaignModelMasterRequest;
import io.gs2.serialKey.result.UpdateCampaignModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
UpdateCampaignModelMasterResult result = client.updateCampaignModelMaster(
new UpdateCampaignModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withDescription("description1")
.withMetadata("{\"hoge\": \"fuga\"}")
.withEnableCampaignCode(null)
);
CampaignModelMaster 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCampaignModelMaster(
new Gs2.Gs2SerialKey.Request.UpdateCampaignModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCampaignModelName("campaign-0001")
.WithDescription("description1")
.WithMetadata("{\"hoge\": \"fuga\"}")
.WithEnableCampaignCode(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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.updateCampaignModelMaster(
new Gs2SerialKey.UpdateCampaignModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
.withDescription("description1")
.withMetadata("{\"hoge\": \"fuga\"}")
.withEnableCampaignCode(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.update_campaign_model_master(
serial_key.UpdateCampaignModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_campaign_model_name('campaign-0001')
.with_description('description1')
.with_metadata('{"hoge": "fuga"}')
.with_enable_campaign_code(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.update_campaign_model_master({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
description="description1",
metadata="{\"hoge\": \"fuga\"}",
enableCampaignCode=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('serial_key')
api_result_handler = client.update_campaign_model_master_async({
namespaceName="namespace-0001",
campaignModelName="campaign-0001",
description="description1",
metadata="{\"hoge\": \"fuga\"}",
enableCampaignCode=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;
```
---
### deleteCampaignModelMaster
Delete Campaign Model Master
Deletes the specified campaign model master. This only removes the master definition and does not affect the currently active campaign model.
#### 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 (.). |
| campaignModelName | string | | ✓| | ~ 128 chars | Campaign Model name |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CampaignModelMaster](#campaignmodelmaster) | Campaign Model Master deleted |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/serialKey"
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 := serial_key.Gs2SerialKeyRestClient{
Session: &session,
}
result, err := client.DeleteCampaignModelMaster(
&serial_key.DeleteCampaignModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CampaignModelName: pointy.String("campaign-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\SerialKey\Gs2SerialKeyRestClient;
use Gs2\SerialKey\Request\DeleteCampaignModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2SerialKeyRestClient(
$session
);
try {
$result = $client->deleteCampaignModelMaster(
(new DeleteCampaignModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCampaignModelName("campaign-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.serialKey.rest.Gs2SerialKeyRestClient;
import io.gs2.serialKey.request.DeleteCampaignModelMasterRequest;
import io.gs2.serialKey.result.DeleteCampaignModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2SerialKeyRestClient client = new Gs2SerialKeyRestClient(session);
try {
DeleteCampaignModelMasterResult result = client.deleteCampaignModelMaster(
new DeleteCampaignModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
);
CampaignModelMaster 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 Gs2SerialKeyRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteCampaignModelMaster(
new Gs2.Gs2SerialKey.Request.DeleteCampaignModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCampaignModelName("campaign-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 Gs2SerialKey from '@/gs2/serialKey';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2SerialKey.Gs2SerialKeyRestClient(session);
try {
const result = await client.deleteCampaignModelMaster(
new Gs2SerialKey.DeleteCampaignModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCampaignModelName("campaign-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import serial_key
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = serial_key.Gs2SerialKeyRestClient(session)
try:
result = client.delete_campaign_model_master(
serial_key.DeleteCampaignModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_campaign_model_name('campaign-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('serial_key')
api_result = client.delete_campaign_model_master({
namespaceName="namespace-0001",
campaignModelName="campaign-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('serial_key')
api_result_handler = client.delete_campaign_model_master_async({
namespaceName="namespace-0001",
campaignModelName="campaign-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;
```
---