GS2-SerialKey SDK API Reference

Specification of models and API references for GS2-SerialKey SDK for various programming languages

Model

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	Required	Default	Value Limits	Description
namespaceId	string	*		~ 1024 chars	Namespace GRN * Set automatically by the server
name	string	✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
description	string			~ 1024 chars	Description
transactionSetting	TransactionSetting				Transaction Setting
logSetting	LogSetting				Log Output Settings
createdAt	long	*	Now		Datetime of creation Unix time, milliseconds * Set automatically by the server
updatedAt	long	*	Now		Datetime of last update Unix time, milliseconds * Set automatically by the server
revision	long		0	0 ~ 9223372036854775805	Revision

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 Acquire Actions via GS2-JobQueue enables robust transaction management tailored to game logic.

	Type	Condition	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 the execution of transactions atomically * Applicable only if enableAutoRun is true
transactionUseDistributor	bool	{enableAtomicCommit} == true	false		Whether to execute transactions asynchronously * Applicable only if enableAtomicCommit is true
commitScriptResultInUseDistributor	bool	{transactionUseDistributor} == true	false		Whether to execute the commit processing of the script result asynchronously * Applicable only if transactionUseDistributor is true
acquireActionUseJobQueue	bool	{enableAtomicCommit} == true	false		Whether to use GS2-JobQueue to execute the acquire action * Applicable 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

LogSetting

Log Output Setting

Manages log output setting. 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:”.

GitHubCheckoutSetting

Setup to check 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

Definition	Description
“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”

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 ~ 1000000

Quantity of Serial Codes issued

issueRequestCount

int

✓

1 ~ 100000

Quantity of Serial Codes issued

status

String Enum
enum {
“PROCESSING”,
“COMPLETE”
}

“PROCESSING”

Status

Definition	Description
“PROCESSING”	Processing of issue
“COMPLETE”	Complete

createdAt

long

Now

Datetime of creation

Unix time, milliseconds
* Set automatically by the server

revision

long

0 ~ 9223372036854775805

Revision

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

code

string

✓

~ 48 chars

Serial Code

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

Definition	Description
“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

Now

Datetime of creation

Unix time, milliseconds
* Set automatically by the server

usedAt

long

Used at

updatedAt

long

Now

Datetime of last update

Unix time, milliseconds
* Set automatically by the server

revision

long

0 ~ 9223372036854775805

Revision

CampaignModel

Campaign Model

A Campaign Model is used to define and manage campaigns, linking them to serial codes.

	Type	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

CurrentCampaignMaster

Currently active Campaign Model master data

This master data describes the definitions of Campaign Models currently active within the namespace. GS2 uses JSON format files for managing master data. By uploading these files, the master data settings are updated on 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.

Note

Please refer to GS2-SerialKey Master Data Reference for the JSON file format.

	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

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	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
createdAt	long	*	Now		Datetime of creation Unix time, milliseconds * Set automatically by the server
updatedAt	long	*	Now		Datetime of last update Unix time, milliseconds * Set automatically by the server
revision	long		0	0 ~ 9223372036854775805	Revision

Methods

describeNamespaces

Get a list of 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	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>	List of Namespace
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/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

createNamespace

Create a new Namespace

You must specify detailed information including the name, description, and various settings of the namespace.

Request

	Type	Required	Value Limits	Description
name	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
description	string		~ 1024 chars	Description
transactionSetting	TransactionSetting			Transaction Setting
logSetting	LogSetting			Log Output Settings

Result

	Type	Description
item	Namespace	Namespace created

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/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

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 Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
status	string

Implementation Example

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

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 Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
item	Namespace	Namespace

Implementation Example

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

updateNamespace

Update Namespace

Update the settings of the specified namespace. You can change the description of the Namespace and specific settings.

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
description	string		~ 1024 chars	Description
transactionSetting	TransactionSetting			Transaction Setting
logSetting	LogSetting			Log Output Settings

Result

	Type	Description
item	Namespace	Namespace updated

Implementation Example

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

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 Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
item	Namespace	The deleted Namespace

Implementation Example

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

getServiceVersion

Get the microservice version

Request

Request parameters: None

Result

	Type	Description
item	string	Version

Implementation Example

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

dumpUserDataByUserId

Dump data associated with the specified user ID

Can be used to meet legal requirements for the protection of personal information, or to back up or migrate data.

Request

	Type	Condition	Required	Default	Value Limits	Description
userId	string		✓		~ 128 chars	User ID
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

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")
}

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

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

cleanUserDataByUserId

Delete user data

Execute cleaning of data associated with the specified user ID This allows you to safely delete specific user data from the project.

Request

	Type	Condition	Required	Default	Value Limits	Description
userId	string		✓		~ 128 chars	User ID
timeOffsetToken	string				~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

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")
}

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

	Type	Description

Implementation Example

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")
}

prepareImportUserDataByUserId

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.

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

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

importUserDataByUserId

Execute import of data associated with the specified user ID

Before calling this API, you must call prepareImportUserDataByUserId to complete the upload preparation.

Request

	Type	Required	Value Limits	Description
userId	string	✓	~ 128 chars	User ID
uploadToken	string	✓	~ 1024 chars	Token received in preparation for upload
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description

Implementation Example

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")
}

checkImportUserDataByUserId

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

Request

	Type	Required	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

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

describeIssueJobs

Get a list of Serial Code Issuance Jobs

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific 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>	List of Serial Code Issuance Jobs
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/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

getIssueJob

Get Serial Code Issuance Job

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific 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	Serial Code Issuance Job

Implementation Example

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

issue

Create a new Serial Code Issuance Job

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific 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 issued

Result

	Type	Description
item	IssueJob	Serial Code Issuance Job

Implementation Example

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

describeSerialKeys

Get a list of Serial Codes

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific 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>	List of Serial Code
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/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

downloadSerialCodes

Get a list of serial codes by file

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific 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

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

issueOnce

Issue a serial code

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific 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	Serial Code

Implementation Example

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

getSerialKey

Get serial code

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
code	string		✓		~ 48 chars	Serial Code

Result

	Type	Description
item	SerialKey	Serial Code
campaignModel	CampaignModel	Campaign Model

Implementation Example

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

verifyCode

Verify the validity of the serial code

Request

Type

Condition

Required

Default

Value Limits

Description

namespaceName

string

✓

~ 128 chars

Namespace name

Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

accessToken

string

✓

~ 128 chars

Access token

code

string

✓

~ 48 chars

Serial Code

campaignModelName

string

~ 128 chars

Campaign name

verifyType

String Enum
enum {
“active”,
“inactive”
}

✓

Verification type

Definition	Description
“active”	Active
“inactive”	Inactive

Result

	Type	Description
item	SerialKey	Serial Code
campaignModel	CampaignModel	Campaign Model

Implementation Example

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("used"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
campaignModel := result.CampaignModel

verifyCodeByUserId

Verify the validity of the Serial Code by specifying a user ID

Request

Type

Condition

Required

Default

Value Limits

Description

namespaceName

string

✓

~ 128 chars

Namespace name

Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

userId

string

✓

~ 128 chars

User ID

code

string

✓

~ 48 chars

Serial Code

campaignModelName

string

~ 128 chars

Campaign name

verifyType

String Enum
enum {
“active”,
“inactive”
}

✓

Verification type

Definition	Description
“active”	Active
“inactive”	Inactive

timeOffsetToken

string

~ 1024 chars

Time offset token

Result

	Type	Description
item	SerialKey	Serial Code
campaignModel	CampaignModel	Campaign Model

Implementation Example

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("used"),
        TimeOffsetToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item
campaignModel := result.CampaignModel

use

Using serial code

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
accessToken	string	✓	~ 128 chars	Access token
code	string	✓	~ 48 chars	Serial Code

Result

	Type	Description
item	SerialKey	Serial Code
campaignModel	CampaignModel	Campaign Model

Implementation Example

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

useByUserId

Using Serial Code by specifying a user ID

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
userId	string	✓	~ 128 chars	User ID
code	string	✓	~ 48 chars	Serial Code
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	SerialKey	Serial Code
campaignModel	CampaignModel	Campaign Model

Implementation Example

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

revertUseByUserId

Serial Code set to unused by specifying a user ID

Request

	Type	Required	Value Limits	Description
namespaceName	string	✓	~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
userId	string	✓	~ 128 chars	User ID
code	string	✓	~ 48 chars	Serial Code
timeOffsetToken	string		~ 1024 chars	Time offset token

Result

	Type	Description
item	SerialKey	Serial Code
campaignModel	CampaignModel	Campaign Model

Implementation Example

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

describeCampaignModels

Get a list of Campaign Models

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
items	List<CampaignModel>	List of Campaign Model

Implementation Example

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

getCampaignModel

Get Campaign Model

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
campaignModelName	string		✓		~ 128 chars	Campaign Model name

Result

	Type	Description
item	CampaignModel	Campaign Model

Implementation Example

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("1111campaign-0001"),
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

exportMaster

Export Campaign Model Master in a format that permits master data activation

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
item	CurrentCampaignMaster	Campaign Model master data that can be activated

Implementation Example

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

getCurrentCampaignMaster

Get currently active Campaign Model master data

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

Result

	Type	Description
item	CurrentCampaignMaster	Currently active Campaign Model master data

Implementation Example

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

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.

Execute this API to obtain a token and URL for uploading.
Upload the master data to the obtained URL.
Execute UpdateCurrentModelMaster by passing the token obtained from the the upload to reflect the master data.

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific 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

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

updateCurrentCampaignMaster

Update currently active Campaign Model master data

Request

Type

Condition

Required

Default

Value Limits

Description

namespaceName

string

✓

~ 128 chars

Namespace name

Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).

mode

String Enum
enum {
“direct”,
“preUpload”
}

“direct”

Update mode

Definition	Description
“direct”	Directly update the master data
“preUpload”	Upload master data and then update

settings

string

{mode} == “direct”

✓*

~ 5242880 chars

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	Updated master data of the currently active Campaign Models

Implementation Example

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, \"enableLimit\": false}]}"),
        UploadToken: nil,
    }
)
if err != nil {
    panic("error occurred")
}
item := result.Item

updateCurrentCampaignMasterFromGitHub

Update currently active Campaign Model master data from GitHub

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
checkoutSetting	GitHubCheckoutSetting		✓			Setup to check out master data from GitHub

Result

	Type	Description
item	CurrentCampaignMaster	Updated master data of the currently active Campaign Models

Implementation Example

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

describeCampaignModelMasters

Get a list of Campaign Model Master

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific 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>	List of Campaign Model Masters
nextPageToken	string	Page token to retrieve the rest of the listing

Implementation Example

import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/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

createCampaignModelMaster

Create a new Campaign Model Master Data

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific 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

Result

	Type	Description
item	CampaignModelMaster	Created Campaign Model Master Data

Implementation Example

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

getCampaignModelMaster

Get a Campaign Model Master Data

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
campaignModelName	string		✓		~ 128 chars	Campaign Model name

Result

	Type	Description
item	CampaignModelMaster	Campaign Model Master Data

Implementation Example

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

updateCampaignModelMaster

Update Campaign Model Master

Request

	Type	Required	Default	Value Limits	Description
namespaceName	string	✓		~ 128 chars	Namespace name Namespace-specific 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

Result

	Type	Description
item	CampaignModelMaster	Campaign Model Master updated

Implementation Example

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

deleteCampaignModelMaster

Delete Campaign Model Master

Request

	Type	Condition	Required	Default	Value Limits	Description
namespaceName	string		✓		~ 128 chars	Namespace name Namespace-specific name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.).
campaignModelName	string		✓		~ 128 chars	Campaign Model name

Result

	Type	Description
item	CampaignModelMaster	Campaign Model Master deleted

Implementation Example

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