> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Lottery SDK API Reference
Specification of models and API references for GS2-Lottery 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 lottery operations. Lottery draws issue transactions that grant prizes to users via acquire actions. |
| lotteryTriggerScriptId | string | | | | ~ 1024 chars | GS2-Script script GRN to be called when the lottery is executed
Script Trigger Reference - [`lottery`](../script/#lottery) |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Specifies the GS2-Log Namespace for outputting API request and response logs of lottery operations. Useful for tracking draw results, prize distributions, and box gacha states for debugging and analytics. |
| createdAt | long | | * | Current time | | Creation Timestamp
Unix time, milliseconds
* Set automatically by the server |
| updatedAt | long | | * | Current time | | Last Updated Timestamp
Unix time, milliseconds
* Set automatically by the server |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | Revision |
**Related methods:**
describeNamespaces - List Namespaces
createNamespace - Create Namespace
getNamespace - Get Namespace
updateNamespace - Update Namespace
deleteNamespace - Delete Namespace
---
### TransactionSetting
Transaction Setting
Transaction Setting controls execution methods, consistency, asynchronous processing, and conflict avoidance mechanisms of transactions.
Combining features like AutoRun, AtomicCommit, asynchronous execution using GS2-Distributor, batch application of script results, and asynchronous processing of Acquire Actions via GS2-JobQueue enables robust transaction management tailored to game logic.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| enableAutoRun | bool | | | false | | Whether to automatically execute issued transactions on the server side |
| enableAtomicCommit | bool | {enableAutoRun} == true | | false | | Whether to commit transactions atomically
* Enabled only if enableAutoRun is true |
| transactionUseDistributor | bool | {enableAtomicCommit} == true | | false | | Whether to execute transactions asynchronously
* Enabled only if enableAtomicCommit is true |
| commitScriptResultInUseDistributor | bool | {transactionUseDistributor} == true | | false | | Whether to execute the commit processing of the script result asynchronously
* Enabled only if transactionUseDistributor is true |
| acquireActionUseJobQueue | bool | {enableAtomicCommit} == true | | false | | Whether to use GS2-JobQueue to execute the acquire action
* Enabled only if enableAtomicCommit is true |
| distributorNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:distributor:default" | ~ 1024 chars | GS2-Distributor Namespace GRN used to execute transactions |
| queueNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:queue:default" | ~ 1024 chars | GS2-JobQueue Namespace GRN used to execute transactions |
**Related methods:**
createNamespace - Create Namespace
updateNamespace - Update Namespace
**Related models:**
Namespace - Namespace
---
### LogSetting
Log Output Setting
Log Output Setting defines how log data is exported. This type holds the GS2-Log Namespace identifier (Namespace ID), which is used to export log data.
Specify the GS2-Log Namespace where log data is collected and stored in the GRN format for the Log Namespace ID (loggingNamespaceId).
Configuring this setting ensures that log data for API requests and responses occurring within the specified Namespace is output to the target GS2-Log Namespace.
GS2-Log provides real-time logs that can be used for system monitoring, analysis, debugging, and other operational purposes.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| loggingNamespaceId | string | | ✓ | | ~ 1024 chars | GS2-Log Namespace GRN to output logs
Must be specified in GRN format starting with "grn:gs2:". |
**Related methods:**
createNamespace - Create Namespace
updateNamespace - Update Namespace
**Related models:**
Namespace - Namespace
---
### GitHubCheckoutSetting
Setting for checking out master data from GitHub
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| apiKeyId | string | | ✓ | | ~ 1024 chars | GitHub API Key GRN |
| repositoryName | string | | ✓ | | ~ 1024 chars | Repository Name |
| sourcePath | string | | ✓ | | ~ 1024 chars | Master data (JSON) file path |
| referenceType | string (enum)
enum {
"commit_hash",
"branch",
"tag"
}
| | ✓ | | | Source of code"commit_hash": Commit hash / "branch": Branch / "tag": Tag / |
| commitHash | string | {referenceType} == "commit_hash" | ✓* | | ~ 1024 chars | Commit hash
* Required if referenceType is "commit_hash" |
| branchName | string | {referenceType} == "branch" | ✓* | | ~ 1024 chars | Branch Name
* Required if referenceType is "branch" |
| tagName | string | {referenceType} == "tag" | ✓* | | ~ 1024 chars | Tag Name
* Required if referenceType is "tag" |
**Related methods:**
updateCurrentLotteryMasterFromGitHub - Update Currently Active Lottery Model Master Data from GitHub
---
### PrizeTable
Prize Table
A prize can either specify an acquire action directly or reference another Prize Table.
By nesting Prize Tables, you can configure a two-step drawing process—for example, the first step determines the rarity such as SSR, SR, or R, and the second step selects a specific item corresponding to that rarity.
This structure makes it easier to manage and adjust the overall distribution rates for each rarity in the game.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| prizeTableId | string | | * | | ~ 1024 chars | Prize Table GRN
* Set automatically by the server |
| name | string | | ✓ | | ~ 128 chars | Prize Table name
Unique Prize Table name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| metadata | string | | | | ~ 128 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. |
| prizes | [List<Prize>](#prize) | | ✓ | | 1 ~ 100 items | Prizes
The list of prizes in this Prize Table. Each prize defines its draw weight (probability), the actions to execute when drawn, and optionally a draw limit. The actual draw probability of each prize is calculated as its weight divided by the total weight of all prizes in the table. |
**Related methods:**
describePrizeTables - List Prize Tables
getPrizeTable - Get Prize Table
---
### Probability
Draw Probability
Represents the calculated draw probability for a specific prize. The rate is computed from the prize's weight relative to the total weight of all prizes in the Prize Table. For box gacha, the probability changes dynamically as prizes are drawn from the box.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| prize | [DrawnPrize](#drawnprize) | | ✓ | | | Prize
The prize that this probability corresponds to, including its ID and acquire actions. |
| rate | float | | ✓ | | 0 ~ 1.0 | Draw Probability (0.0-1.0)
The probability of drawing this prize, expressed as a value between 0.0 and 1.0. Calculated as this prize's weight divided by the total weight of all prizes in the table. |
**Related methods:**
describeProbabilities - List Draw Probabilities
describeProbabilitiesByUserId - List Draw Probabilities by User ID
---
### PrizeLimit
Prize Limit
Tracks the number of times a specific prize has been drawn across all users. When the drawn count reaches the maximum defined in the Prize's drawnLimit, the failover prize is drawn instead. Used to implement limited-quantity prizes such as rare jackpot items.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| prizeLimitId | string | | * | | ~ 1024 chars | Prize Limit GRN
* Set automatically by the server |
| prizeId | string | | ✓ | | ~ 36 chars | Prize ID
The ID of the prize whose draw count is being tracked. |
| drawnCount | int | | ✓ | | 0 ~ 2147483646 | Drawn Count
The current number of times this prize has been drawn across all users. Compared against the Prize's drawnLimit to determine if the failover prize should be used. |
| 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:**
describePrizeLimits - List Prize Limits
getPrizeLimit - Get Prize Limit
---
### DrawnPrize
Drawn Prize
Represents a prize that has been drawn from the lottery. Contains the prize ID and the acquire actions that were executed to grant the prize to the user.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| prizeId | string | | ✓ | | ~ 36 chars | Prize ID
The ID of the drawn prize, corresponding to a prize entry in the Prize Table. |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | | 0 ~ 100 items | List of Acquire Actions
The list of acquire actions executed to grant this prize to the user. |
**Related models:**
Probability - Draw Probability
---
### BoxItems
Box Items
Records the state of a box gacha for a specific user and Prize Table. Contains the list of all prizes in the box along with their remaining and initial quantities, allowing the user to see which prizes have been drawn and which remain.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| boxId | string | | * | | ~ 1024 chars | Box GRN
* Set automatically by the server |
| prizeTableName | string | | ✓ | | ~ 128 chars | Prize Table name
The name of the Prize Table associated with this box. Identifies which box gacha this record belongs to. |
| userId | string | | ✓ | | ~ 128 chars | User ID |
| items | [List<BoxItem>](#boxitem) | | | [] | 0 ~ 1000 items | Items
The list of all prizes in the box with their remaining and initial quantities. Each item shows how many of that prize were originally in the box and how many remain, allowing tracking of the box gacha's draw progress. |
**Related methods:**
describeBoxes - List items extracted from the box
describeBoxesByUserId - List boxes by User ID
getBox - Get Box
getBoxByUserId - Get Box by User ID
resetBox - Reset Box
resetBoxByUserId - Reset box with specified user ID
---
### LotteryModel
Lottery Model
Lottery Model is an entity that defines the draw method and how to reference the draw table.
Two draw methods are available: Normal Draw, which performs draws with a fixed probability each time, and Box Draw, where a predetermined number of prizes are placed in a box, and prizes are drawn from the box one by one with each draw.
The lottery process uses a Prize Table.
GS2-Script can be used to dynamically select the Prize Table with a different table when multiple drawings are performed.
By using this mechanism, it is possible to apply a different Prize Table only once in a 10-round gacha.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| lotteryModelId | string | | * | | ~ 1024 chars | Lottery Model GRN
* Set automatically by the server |
| name | string | | ✓ | | ~ 128 chars | Lottery Model name
Unique Lottery Model name. Specified using alphanumeric characters, hyphen (-), underscore (_), and period (.). |
| 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. |
| mode | string (enum)
enum {
"normal",
"box"
}
| | ✓ | | | Drawing Mode
Select the prize drawing method. "normal" performs draws with a fixed probability each time (prizes can be drawn repeatedly). "box" places a predetermined number of prizes in a virtual box, and each draw removes a prize from the box (guaranteeing all prizes will eventually be drawn)."normal": Normal Draw / "box": Box Draw / |
| method | string (enum)
enum {
"prize_table",
"script"
}
| | ✓ | | | Prize Table Selection Method
Determines how the Prize Table is referenced. "prize_table" uses a statically specified Prize Table. "script" uses GS2-Script to dynamically select the Prize Table at draw time, enabling scenarios like applying a different Prize Table for one draw in a 10-draw gacha."prize_table": Static Prize Table / "script": Dynamically selected Prize Table using GS2-Script / |
| prizeTableName | string | {method} == "prize_table" | ✓* | | ~ 128 chars | Prize Table Name
The name of the Prize Table to use for this lottery model. Required when the lottery method is "prize_table".
* Required if method is "prize_table" |
| choicePrizeTableScriptId | string | {method} == "script" | ✓* | | ~ 1024 chars | GS2-Script script GRN to determine the Prize Table
Script Trigger Reference - [`choicePrizeTable`](../script/#choiceprizetable)
* Required if method is "script" |
**Related methods:**
describeLotteryModels - List Lottery Models
getLotteryModel - Get Lottery Model
---
### Prize
Prize
A single prize entry within a Prize Table.
A prize can either directly specify acquire actions (granting items, currency, etc.) or reference another Prize Table to perform a nested draw.
Each prize has a draw weight that determines its relative probability of being drawn.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| prizeId | string | | ✓ | UUID | ~ 36 chars | Prize ID
A unique identifier for this prize within the Prize Table. Used to track draw limits and as a reference when specifying failover prizes. |
| type | string (enum)
enum {
"action",
"prize_table"
}
| | ✓ | | | Prize Type
Determines whether this prize directly grants rewards or delegates to another Prize Table. "action" specifies acquire actions to execute when drawn. "prize_table" references another Prize Table for a nested drawing (e.g., first draw determines rarity, second draw determines specific item)."action": Acquire Actions for the prize / "prize_table": Delegates the draw to another Prize Table (performs a nested draw). / |
| acquireActions | [List<AcquireAction>](#acquireaction) | {type} == "action" | | [] | 1 ~ 100 items | List of Acquire Actions
The list of acquire actions to execute when this prize is drawn. Multiple actions can be specified to grant several rewards at once (e.g., an item and currency together).
* Enabled only if type is "action" |
| drawnLimit | int | {type} == "action" | | | 1 ~ 1000000 | Maximum Number of Draws
The maximum number of times this prize can be drawn across all users. When the limit is reached, the failover prize (limitFailOverPrizeId) is drawn instead. Used to implement limited-quantity prizes such as jackpot items.
* Enabled only if type is "action" |
| limitFailOverPrizeId | string | {type} == "action" and {drawnLimit} > 0 | ✓* | | ~ 32 chars | Limit Failover Prize ID
The ID of the prize to draw instead when this prize's draw limit (drawnLimit) has been reached. Must reference another prize within the same Prize Table.
* Required if type is "action" and drawnLimit is greater than 0 |
| prizeTableName | string | {type} == "prize_table" | ✓* | | ~ 128 chars | Prize Table Name
The name of the Prize Table to delegate the draw to. Used when the prize type is "prize_table" for nested drawing.
* Required if type is "prize_table" |
| weight | int | | ✓ | | 1 ~ 2147483646 | Draw Weight
The relative weight of this prize in the Prize Table. The actual draw probability is calculated as this prize's weight divided by the total weight of all prizes in the table. For example, if three prizes have weights of 70, 20, and 10, their draw probabilities are 70%, 20%, and 10% respectively. |
**Related models:**
PrizeTable - Prize Table
PrizeTableMaster - Prize Table Master
---
### BoxItem
Box Item
Represents a single prize type within a box gacha, showing its initial quantity in the box, remaining quantity, and the acquire actions that will be executed when drawn.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| prizeId | string | | ✓ | | ~ 128 chars | Prize ID
The ID of the prize in the Prize Table that this box item corresponds to. |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | [] | 0 ~ 100 items | List of Acquire Actions
The list of acquire actions to execute when this prize is drawn from the box. |
| remaining | int | | ✓ | | 0 ~ 2147483646 | Remaining Quantity
The number of this prize still remaining in the box. Decreases by one each time this prize is drawn. |
| initial | int | | ✓ | | 0 ~ 2147483646 | Initial Quantity
The number of this prize that was originally placed in the box. Used together with remaining to calculate how many have been drawn. |
**Related models:**
BoxItems - Box Items
---
### AcquireAction
Acquire Action
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| action | string (enum)
enum {
}
| | ✓ | | | Type of Acquire Action |
| request | string | | ✓ | | ~ 524288 chars | JSON string of the request used when executing the action |
**Related models:**
DrawnPrize - Drawn Prize
Prize - Prize
BoxItem - Box Item
---
### Config
Configuration
Configuration values applied to transaction variables
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| key | string | | ✓ | | ~ 64 chars | Name |
| value | string | | | | ~ 51200 chars | Value |
---
### VerifyActionResult
Verify Action execution result
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| action | string (enum)
enum {
}
| | ✓ | | | Type of Verify Action |
| verifyRequest | string | | ✓ | | ~ 524288 chars | JSON string of the request used when executing the action |
| statusCode | int | | | | 0 ~ 999 | Status code |
| verifyResult | string | | | | ~ 1048576 chars | Result content |
**Related models:**
TransactionResult - Transaction Execution Result
---
### ConsumeActionResult
Consume Action execution result
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| action | string (enum)
enum {
}
| | ✓ | | | Type of Consume Action |
| consumeRequest | string | | ✓ | | ~ 524288 chars | JSON string of the request used when executing the action |
| statusCode | int | | | | 0 ~ 999 | Status code |
| consumeResult | string | | | | ~ 1048576 chars | Result content |
**Related models:**
TransactionResult - Transaction Execution Result
---
### AcquireActionResult
Acquire Action execution result
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| action | string (enum)
enum {
}
| | ✓ | | | Type of Acquire Action |
| acquireRequest | string | | ✓ | | ~ 524288 chars | JSON string of the request used when executing the action |
| statusCode | int | | | | 0 ~ 999 | Status code |
| acquireResult | string | | | | ~ 1048576 chars | Result content |
**Related models:**
TransactionResult - Transaction Execution Result
---
### TransactionResult
Transaction Execution Result
Result of a transaction executed using the server-side automatic execution feature
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| transactionId | string | | ✓ | | 36 ~ 36 chars | Transaction ID |
| verifyResults | [List<VerifyActionResult>](#verifyactionresult) | | | | 0 ~ 10 items | List of verify action execution results |
| consumeResults | [List<ConsumeActionResult>](#consumeactionresult) | | | [] | 0 ~ 10 items | List of Consume Action execution results |
| acquireResults | [List<AcquireActionResult>](#acquireactionresult) | | | [] | 0 ~ 100 items | List of Acquire Action execution results |
| hasError | bool | | | false | | Whether an error occurred during transaction execution |
---
### CurrentLotteryMaster
Currently active Lottery Model master data
This master data defines the Lottery 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-Lottery Master Data Reference](api_reference/lottery/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 Lottery Model Master in a master data format that can be activated
getCurrentLotteryMaster - Get currently active Lottery Model master data
updateCurrentLotteryMaster - Update Currently Active Lottery Model Master Data
updateCurrentLotteryMasterFromGitHub - Update Currently Active Lottery Model Master Data from GitHub
---
### LotteryModelMaster
Lottery Model Master
Lottery Model Master is data used to edit and manage Lottery Models within the game. It is temporarily stored in the Management Console's Master Data Editor.
By performing import and update processes, it is reflected as Lottery Model actually referenced by the game.
Lottery Model is the entity that defines the draw method and draw rate.
Two draw methods are available: Normal Draw, which performs draws with a fixed probability each time, and Box Draw, where a predetermined number of prizes are placed in a box, and prizes are drawn from the box one by one with each draw.
The lottery process uses a Prize Table.
GS2-Script can be used to dynamically select the Prize Table with a different table when multiple drawings are performed.
By using this mechanism, it is possible to apply a different Prize Table only once in a 10-round gacha.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| lotteryModelId | string | | * | | ~ 1024 chars | Lottery Model Master GRN
* Set automatically by the server |
| name | string | | ✓ | | ~ 128 chars | Lottery Model name
Unique Lottery Model name. Specified using alphanumeric characters, hyphen (-), underscore (_), and period (.). |
| 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. |
| description | string | | | | ~ 1024 chars | Description |
| mode | string (enum)
enum {
"normal",
"box"
}
| | ✓ | | | Drawing Mode
Select the prize drawing method. "normal" performs draws with a fixed probability each time (prizes can be drawn repeatedly). "box" places a predetermined number of prizes in a virtual box, and each draw removes a prize from the box (guaranteeing all prizes will eventually be drawn)."normal": Normal Draw / "box": Box Draw / |
| method | string (enum)
enum {
"prize_table",
"script"
}
| | ✓ | | | Prize Table Selection Method
Determines how the Prize Table is referenced. "prize_table" uses a statically specified Prize Table.
"script" uses GS2-Script to dynamically select the Prize Table at draw time, enabling scenarios such as applying a different drop probability table just once during a 10-draw gacha."prize_table": Static Prize Table / "script": Dynamically selected Prize Table using GS2-Script / |
| prizeTableName | string | {method} == "prize_table" | ✓* | | ~ 128 chars | Prize Table Name
The name of the Prize Table to use for this lottery model. Required when the lottery method is "prize_table".
* Required if method is "prize_table" |
| choicePrizeTableScriptId | string | {method} == "script" | ✓* | | ~ 1024 chars | GS2-Script script GRN to determine the Prize Table
Script Trigger Reference - [`choicePrizeTable`](../script/#choiceprizetable)
* Required if method is "script" |
| 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:**
describeLotteryModelMasters - List Lottery Model Masters
createLotteryModelMaster - Create Lottery Model Master
getLotteryModelMaster - Get Lottery Model Master
updateLotteryModelMaster - Update Lottery Model Master
deleteLotteryModelMaster - Delete Lottery Model Master
---
### PrizeTableMaster
Prize Table Master
Prize Table Master is data used to edit and manage Prize Table 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 Prize Table actually referenced by the game.
A prize can either specify an acquire action directly or reference another Prize Table.
By nesting Prize Tables, you can configure a two-step drawing process—for example, the first step determines the rarity such as SSR, SR, or R, and the second step selects a specific item corresponding to that rarity.
This structure makes it easier to manage and adjust the overall distribution rates for each rarity in the game.
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| prizeTableId | string | | * | | ~ 1024 chars | Prize Table Master GRN
* Set automatically by the server |
| name | string | | ✓ | | ~ 128 chars | Prize Table Name
Unique Prize Table name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| metadata | string | | | | ~ 128 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. |
| description | string | | | | ~ 1024 chars | Description |
| prizes | [List<Prize>](#prize) | | ✓ | | 1 ~ 100 items | Prizes
The list of prizes in this Prize Table. Each prize defines its draw weight (probability), the actions to execute when drawn, and optionally a draw limit. The actual draw probability of each prize is calculated as its weight divided by the total weight of all prizes in the table. |
| 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:**
describePrizeTableMasters - List Prize Table Masters
createPrizeTableMaster - Create Prize Table Master
getPrizeTableMaster - Get Prize Table Master
updatePrizeTableMaster - Update Prize Table Master
deletePrizeTableMaster - Delete Prize Table 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeNamespacesRequest;
import io.gs2.lottery.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_namespaces(
lottery.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('lottery')
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('lottery')
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 lottery operations. Lottery draws issue transactions that grant prizes to users via acquire actions. |
| lotteryTriggerScriptId | string | | | | ~ 1024 chars | GS2-Script script GRN to be called when the lottery is executed
Script Trigger Reference - [`lottery`](../script/#lottery) |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Specifies the GS2-Log Namespace for outputting API request and response logs of lottery operations. Useful for tracking draw results, prize distributions, and box gacha states for debugging and analytics. |
#### 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&lottery.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
TransactionSetting: &lottery.TransactionSetting{
EnableAutoRun: pointy.Bool(false),
QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"),
},
LotteryTriggerScriptId: nil,
LogSetting: &lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting((new \Gs2\Lottery\Model\TransactionSetting())
->withEnableAutoRun(false)
->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
->withLotteryTriggerScriptId(null)
->withLogSetting((new \Gs2\Lottery\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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CreateNamespaceRequest;
import io.gs2.lottery.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(new io.gs2.lottery.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.withLotteryTriggerScriptId(null)
.withLogSetting(new io.gs2.lottery.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2Lottery.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(new Gs2.Gs2Lottery.Model.TransactionSetting()
.WithEnableAutoRun(false)
.WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.WithLotteryTriggerScriptId(null)
.WithLogSetting(new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.createNamespace(
new Gs2Lottery.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(new Gs2Lottery.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001"))
.withLotteryTriggerScriptId(null)
.withLogSetting(new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.create_namespace(
lottery.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_transaction_setting(
lottery.TransactionSetting()
.with_enable_auto_run(False)
.with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001'))
.with_lottery_trigger_script_id(None)
.with_log_setting(
lottery.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('lottery')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
},
lotteryTriggerScriptId=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('lottery')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0001",
},
lotteryTriggerScriptId=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getNamespaceStatus
Get Namespace Status
Get the current status of the specified Namespace.
This includes whether the Namespace is active, pending, or in some other state.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| status | string | |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetNamespaceStatusRequest;
import io.gs2.lottery.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2Lottery.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_namespace_status(
lottery.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetNamespaceRequest;
import io.gs2.lottery.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getNamespace(
new Gs2Lottery.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_namespace(
lottery.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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 lottery operations. Lottery draws issue transactions that grant prizes to users via acquire actions. |
| lotteryTriggerScriptId | string | | | | ~ 1024 chars | GS2-Script script GRN to be called when the lottery is executed
Script Trigger Reference - [`lottery`](../script/#lottery) |
| logSetting | [LogSetting](#logsetting) | | | | | Log Output Setting
Specifies the GS2-Log Namespace for outputting API request and response logs of lottery operations. Useful for tracking draw results, prize distributions, and box gacha states for debugging and analytics. |
#### 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&lottery.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
TransactionSetting: &lottery.TransactionSetting{
EnableAutoRun: pointy.Bool(false),
QueueNamespaceId: pointy.String("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"),
},
LotteryTriggerScriptId: nil,
LogSetting: &lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting((new \Gs2\Lottery\Model\TransactionSetting())
->withEnableAutoRun(false)
->withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
->withLotteryTriggerScriptId(null)
->withLogSetting((new \Gs2\Lottery\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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.UpdateNamespaceRequest;
import io.gs2.lottery.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(new io.gs2.lottery.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.withLotteryTriggerScriptId(null)
.withLogSetting(new io.gs2.lottery.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2Lottery.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(new Gs2.Gs2Lottery.Model.TransactionSetting()
.WithEnableAutoRun(false)
.WithQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.WithLotteryTriggerScriptId(null)
.WithLogSetting(new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2Lottery.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(new Gs2Lottery.model.TransactionSetting()
.withEnableAutoRun(false)
.withQueueNamespaceId("grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002"))
.withLotteryTriggerScriptId(null)
.withLogSetting(new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.update_namespace(
lottery.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_transaction_setting(
lottery.TransactionSetting()
.with_enable_auto_run(False)
.with_queue_namespace_id('grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002'))
.with_lottery_trigger_script_id(None)
.with_log_setting(
lottery.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('lottery')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
},
lotteryTriggerScriptId=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('lottery')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
transactionSetting={
enableAutoRun=false,
queueNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:queue:queue-0002",
},
lotteryTriggerScriptId=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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DeleteNamespaceRequest;
import io.gs2.lottery.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2Lottery.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.delete_namespace(
lottery.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetServiceVersionRequest;
import io.gs2.lottery.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2Lottery.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_service_version(
lottery.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
api_result_handler = client.get_service_version_async({
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### dumpUserDataByUserId
Dump data associated with the specified user ID
Can be used to meet legal requirements for the protection of personal information, or to back up or migrate data.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DumpUserDataByUserIdRequest;
import io.gs2.lottery.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2Lottery.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.dump_user_data_by_user_id(
lottery.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.lottery.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2Lottery.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
lottery.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('lottery')
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('lottery')
api_result_handler = client.check_dump_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
url = result.url;
```
---
### cleanUserDataByUserId
Delete user data
Execute cleaning of data associated with the specified user ID
This allows you to safely delete specific user data from the project.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CleanUserDataByUserIdRequest;
import io.gs2.lottery.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2Lottery.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.clean_user_data_by_user_id(
lottery.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
api_result_handler = client.clean_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
```
---
### checkCleanUserDataByUserId
Check if the cleaning of the data associated with the specified user ID is complete
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.lottery.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2Lottery.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
lottery.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.lottery.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
lottery.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('lottery')
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('lottery')
api_result_handler = client.prepare_import_user_data_by_user_id_async({
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
uploadToken = result.uploadToken;
uploadUrl = result.uploadUrl;
```
---
### importUserDataByUserId
Execute import of data associated with the specified user ID
The data that can be used for import is limited to the data exported by GS2, and old data may fail to import.
You can import data with a user ID different from the one you exported, but if the user ID is included in the payload of the user data, this may not be the case.
Before calling this API, you must call prepareImportUserDataByUserId to complete the upload preparation.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128 chars | User ID |
| uploadToken | string | | ✓| | ~ 1024 chars | Token received in preparation for upload |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.ImportUserDataByUserIdRequest;
import io.gs2.lottery.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2Lottery.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.import_user_data_by_user_id(
lottery.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('lottery')
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('lottery')
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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CheckImportUserDataByUserIdRequest;
import io.gs2.lottery.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.check_import_user_data_by_user_id(
lottery.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('lottery')
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('lottery')
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;
```
---
### describePrizeTables
List Prize Tables
Retrieves the list of currently active Prize Tables for the specified Namespace.
Prize Tables define the prizes and their draw probabilities or weights used by lottery models.
#### 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<PrizeTable>](#prizetable) | List of Prize Tables |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribePrizeTables(
&lottery.DescribePrizeTablesRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribePrizeTablesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describePrizeTables(
(new DescribePrizeTablesRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribePrizeTablesRequest;
import io.gs2.lottery.result.DescribePrizeTablesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribePrizeTablesResult result = client.describePrizeTables(
new DescribePrizeTablesRequest()
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribePrizeTables(
new Gs2.Gs2Lottery.Request.DescribePrizeTablesRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describePrizeTables(
new Gs2Lottery.DescribePrizeTablesRequest()
.withNamespaceName("namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_prize_tables(
lottery.DescribePrizeTablesRequest()
.with_namespace_name('namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_prize_tables({
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('lottery')
api_result_handler = client.describe_prize_tables_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;
```
---
### getPrizeTable
Get Prize Table
Retrieves the specified Prize Table, including its list of prizes with their draw probabilities, weights, and quantity limits.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table name
Unique Prize Table name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [PrizeTable](#prizetable) | Prize Table |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetPrizeTable(
&lottery.GetPrizeTableRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetPrizeTableRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getPrizeTable(
(new GetPrizeTableRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetPrizeTableRequest;
import io.gs2.lottery.result.GetPrizeTableResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetPrizeTableResult result = client.getPrizeTable(
new GetPrizeTableRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
PrizeTable 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetPrizeTable(
new Gs2.Gs2Lottery.Request.GetPrizeTableRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getPrizeTable(
new Gs2Lottery.GetPrizeTableRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_prize_table(
lottery.GetPrizeTableRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_prize_table({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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('lottery')
api_result_handler = client.get_prize_table_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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;
```
---
### drawByUserId
Execute a lottery by specifying a User ID
Performs a lottery draw for the specified user based on the lottery model configuration.
The lottery supports two methods: Prize Table mode (using predefined probability tables) and Script mode (using a GS2-Script to determine prizes).
In box lottery mode, drawn prizes are removed from the box and cannot be drawn again. If the box is empty, an Empty error is returned.
The drawn prizes are issued as a transaction.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name |
| lotteryName | string | | ✓| | ~ 128 chars | Lottery Model name
Unique Lottery Model name. Specified using alphanumeric characters, hyphen (-), underscore (_), and period (.). |
| userId | string | | ✓| | ~ 128 chars | User ID |
| count | int | | ✓| | 1 ~ 1000 | Number of draws |
| config | [List<Config>](#config) | | | [] | 0 ~ 1000 items | Configuration values applied to transaction placeholders |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | List of Prize emission |
| boxItems | [BoxItems](#boxitems) | List of items taken out of the box |
| transactionId | string | Issued transaction ID |
| stampSheet | string | Stamp sheet to obtain emission prizes |
| stampSheetEncryptionKeyId | string | Cryptographic key GRN used for stamp sheet signature calculations |
| autoRunStampSheet | bool? | Whether automatic transaction execution is enabled |
| atomicCommit | bool? | Whether to commit the transaction atomically |
| transaction | string | Issued transaction |
| transactionResult | [TransactionResult](#transactionresult) | Transaction Execution Result |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DrawByUserId(
&lottery.DrawByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-0001"),
UserId: pointy.String("user-0001"),
Count: pointy.Int32(1),
Config: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
boxItems := result.BoxItems
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet
atomicCommit := result.AtomicCommit
transaction := result.Transaction
transactionResult := result.TransactionResult
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DrawByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->drawByUserId(
(new DrawByUserIdRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-0001")
->withUserId("user-0001")
->withCount(1)
->withConfig(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$boxItems = $result->getBoxItems();
$transactionId = $result->getTransactionId();
$stampSheet = $result->getStampSheet();
$stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
$autoRunStampSheet = $result->getAutoRunStampSheet();
$atomicCommit = $result->getAtomicCommit();
$transaction = $result->getTransaction();
$transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DrawByUserIdRequest;
import io.gs2.lottery.result.DrawByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DrawByUserIdResult result = client.drawByUserId(
new DrawByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withCount(1)
.withConfig(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
BoxItems boxItems = result.getBoxItems();
String transactionId = result.getTransactionId();
String stampSheet = result.getStampSheet();
String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
boolean autoRunStampSheet = result.getAutoRunStampSheet();
boolean atomicCommit = result.getAtomicCommit();
String transaction = result.getTransaction();
TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DrawByUserId(
new Gs2.Gs2Lottery.Request.DrawByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-0001")
.WithUserId("user-0001")
.WithCount(1)
.WithConfig(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var boxItems = result.BoxItems;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.drawByUserId(
new Gs2Lottery.DrawByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withCount(1)
.withConfig(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const boxItems = result.getBoxItems();
const transactionId = result.getTransactionId();
const stampSheet = result.getStampSheet();
const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
const autoRunStampSheet = result.getAutoRunStampSheet();
const atomicCommit = result.getAtomicCommit();
const transaction = result.getTransaction();
const transactionResult = result.getTransactionResult();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.draw_by_user_id(
lottery.DrawByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_user_id('user-0001')
.with_count(1)
.with_config(None)
.with_time_offset_token(None)
)
items = result.items
box_items = result.box_items
transaction_id = result.transaction_id
stamp_sheet = result.stamp_sheet
stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
auto_run_stamp_sheet = result.auto_run_stamp_sheet
atomic_commit = result.atomic_commit
transaction = result.transaction
transaction_result = result.transaction_result
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.draw_by_user_id({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
count=1,
config=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
boxItems = result.boxItems;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.draw_by_user_id_async({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
count=1,
config=nil,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
boxItems = result.boxItems;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### prediction
Get the prediction result of the lottery result
Predicts lottery outcomes without actually awarding prizes or generating transactions.
Uses a random seed for deterministic results, allowing the same prediction to be reproduced with the same seed.
This is useful for showing players what they would receive before committing to the draw.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name |
| lotteryName | string | | ✓| | ~ 128 chars | Lottery Model name |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
| randomSeed | long | | ✓| | 0 ~ 9223372036854775805 | Random seed |
| count | int | | ✓| | 1 ~ 1000 | Number of draws |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | List of Prize emission |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.Prediction(
&lottery.PredictionRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-0001"),
AccessToken: pointy.String("accessToken-0001"),
RandomSeed: pointy.Int64(1),
Count: pointy.Int32(1),
}
)
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\PredictionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->prediction(
(new PredictionRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-0001")
->withAccessToken("accessToken-0001")
->withRandomSeed(1)
->withCount(1)
);
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.PredictionRequest;
import io.gs2.lottery.result.PredictionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
PredictionResult result = client.prediction(
new PredictionRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withAccessToken("accessToken-0001")
.withRandomSeed(1L)
.withCount(1)
);
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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.Prediction(
new Gs2.Gs2Lottery.Request.PredictionRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-0001")
.WithAccessToken("accessToken-0001")
.WithRandomSeed(1L)
.WithCount(1),
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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.prediction(
new Gs2Lottery.PredictionRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withAccessToken("accessToken-0001")
.withRandomSeed(1)
.withCount(1)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.prediction(
lottery.PredictionRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_access_token('accessToken-0001')
.with_random_seed(1)
.with_count(1)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.prediction({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
accessToken="accessToken-0001",
randomSeed=1,
count=1,
})
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('lottery')
api_result_handler = client.prediction_async({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
accessToken="accessToken-0001",
randomSeed=1,
count=1,
})
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;
```
---
### predictionByUserId
Get the prediction result of the lottery result by User ID
Predicts lottery outcomes for the specified user without awarding prizes or generating transactions.
Uses a random seed for deterministic results.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name |
| lotteryName | string | | ✓| | ~ 128 chars | Lottery Model name |
| userId | string | | ✓| | ~ 128 chars | User ID |
| randomSeed | long | | ✓| | 0 ~ 9223372036854775805 | Random seed |
| count | int | | ✓| | 1 ~ 1000 | Number of draws |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | List of Prize emission |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.PredictionByUserId(
&lottery.PredictionByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-0001"),
UserId: pointy.String("user-0001"),
RandomSeed: pointy.Int64(1),
Count: pointy.Int32(1),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\PredictionByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->predictionByUserId(
(new PredictionByUserIdRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-0001")
->withUserId("user-0001")
->withRandomSeed(1)
->withCount(1)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.PredictionByUserIdRequest;
import io.gs2.lottery.result.PredictionByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
PredictionByUserIdResult result = client.predictionByUserId(
new PredictionByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withRandomSeed(1L)
.withCount(1)
.withTimeOffsetToken(null)
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.PredictionByUserId(
new Gs2.Gs2Lottery.Request.PredictionByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-0001")
.WithUserId("user-0001")
.WithRandomSeed(1L)
.WithCount(1)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.predictionByUserId(
new Gs2Lottery.PredictionByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withRandomSeed(1)
.withCount(1)
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.prediction_by_user_id(
lottery.PredictionByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_user_id('user-0001')
.with_random_seed(1)
.with_count(1)
.with_time_offset_token(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.prediction_by_user_id({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
randomSeed=1,
count=1,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.prediction_by_user_id_async({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
randomSeed=1,
count=1,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### drawWithRandomSeedByUserId
Execute a lottery with a random seed by User ID
Performs a deterministic lottery draw using the specified random seed.
The random seed is offset by the iteration count for each draw, ensuring unique but reproducible results.
This method is incompatible with box lottery mode. The drawn prizes are issued as a transaction.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name |
| lotteryName | string | | ✓| | ~ 128 chars | Lottery Model name |
| userId | string | | ✓| | ~ 128 chars | User ID |
| randomSeed | long | | ✓| | 0 ~ 9223372036854775805 | Random seed |
| count | int | | ✓| | 1 ~ 1000 | Number of draws |
| config | [List<Config>](#config) | | | [] | 0 ~ 1000 items | Configuration values applied to transaction placeholders |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | List of Prize emission |
| transactionId | string | Issued transaction ID |
| stampSheet | string | Stamp sheet to obtain emission prizes |
| stampSheetEncryptionKeyId | string | Cryptographic key GRN used for stamp sheet signature calculations |
| autoRunStampSheet | bool? | Whether automatic transaction execution is enabled |
| atomicCommit | bool? | Whether to commit the transaction atomically |
| transaction | string | Issued transaction |
| transactionResult | [TransactionResult](#transactionresult) | Transaction Execution Result |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DrawWithRandomSeedByUserId(
&lottery.DrawWithRandomSeedByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-0001"),
UserId: pointy.String("user-0001"),
RandomSeed: pointy.Int64(1),
Count: pointy.Int32(1),
Config: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
transactionId := result.TransactionId
stampSheet := result.StampSheet
stampSheetEncryptionKeyId := result.StampSheetEncryptionKeyId
autoRunStampSheet := result.AutoRunStampSheet
atomicCommit := result.AtomicCommit
transaction := result.Transaction
transactionResult := result.TransactionResult
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DrawWithRandomSeedByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->drawWithRandomSeedByUserId(
(new DrawWithRandomSeedByUserIdRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-0001")
->withUserId("user-0001")
->withRandomSeed(1)
->withCount(1)
->withConfig(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$transactionId = $result->getTransactionId();
$stampSheet = $result->getStampSheet();
$stampSheetEncryptionKeyId = $result->getStampSheetEncryptionKeyId();
$autoRunStampSheet = $result->getAutoRunStampSheet();
$atomicCommit = $result->getAtomicCommit();
$transaction = $result->getTransaction();
$transactionResult = $result->getTransactionResult();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DrawWithRandomSeedByUserIdRequest;
import io.gs2.lottery.result.DrawWithRandomSeedByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DrawWithRandomSeedByUserIdResult result = client.drawWithRandomSeedByUserId(
new DrawWithRandomSeedByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withRandomSeed(1L)
.withCount(1)
.withConfig(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
String transactionId = result.getTransactionId();
String stampSheet = result.getStampSheet();
String stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
boolean autoRunStampSheet = result.getAutoRunStampSheet();
boolean atomicCommit = result.getAtomicCommit();
String transaction = result.getTransaction();
TransactionResult transactionResult = result.getTransactionResult();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DrawWithRandomSeedByUserId(
new Gs2.Gs2Lottery.Request.DrawWithRandomSeedByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-0001")
.WithUserId("user-0001")
.WithRandomSeed(1L)
.WithCount(1)
.WithConfig(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var transactionId = result.TransactionId;
var stampSheet = result.StampSheet;
var stampSheetEncryptionKeyId = result.StampSheetEncryptionKeyId;
var autoRunStampSheet = result.AutoRunStampSheet;
var atomicCommit = result.AtomicCommit;
var transaction = result.Transaction;
var transactionResult = result.TransactionResult;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.drawWithRandomSeedByUserId(
new Gs2Lottery.DrawWithRandomSeedByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withRandomSeed(1)
.withCount(1)
.withConfig(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const transactionId = result.getTransactionId();
const stampSheet = result.getStampSheet();
const stampSheetEncryptionKeyId = result.getStampSheetEncryptionKeyId();
const autoRunStampSheet = result.getAutoRunStampSheet();
const atomicCommit = result.getAtomicCommit();
const transaction = result.getTransaction();
const transactionResult = result.getTransactionResult();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.draw_with_random_seed_by_user_id(
lottery.DrawWithRandomSeedByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_user_id('user-0001')
.with_random_seed(1)
.with_count(1)
.with_config(None)
.with_time_offset_token(None)
)
items = result.items
transaction_id = result.transaction_id
stamp_sheet = result.stamp_sheet
stamp_sheet_encryption_key_id = result.stamp_sheet_encryption_key_id
auto_run_stamp_sheet = result.auto_run_stamp_sheet
atomic_commit = result.atomic_commit
transaction = result.transaction
transaction_result = result.transaction_result
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.draw_with_random_seed_by_user_id({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
randomSeed=1,
count=1,
config=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.draw_with_random_seed_by_user_id_async({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
randomSeed=1,
count=1,
config=nil,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### describeProbabilities
List Draw Probabilities
The normal lottery responds with the same probability for all game players.
The box draw responds with a different probability for each game player, taking into account the remaining contents of the box.
#### 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 (.). |
| lotteryName | string | | ✓| | ~ 128 chars | Lottery Model name
Unique Lottery Model name. Specified using alphanumeric characters, hyphen (-), underscore (_), and period (.). |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Probability>](#probability) | List of draw probabilities |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeProbabilities(
&lottery.DescribeProbabilitiesRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-0001"),
AccessToken: pointy.String("accessToken-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeProbabilitiesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeProbabilities(
(new DescribeProbabilitiesRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-0001")
->withAccessToken("accessToken-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeProbabilitiesRequest;
import io.gs2.lottery.result.DescribeProbabilitiesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeProbabilitiesResult result = client.describeProbabilities(
new DescribeProbabilitiesRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withAccessToken("accessToken-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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeProbabilities(
new Gs2.Gs2Lottery.Request.DescribeProbabilitiesRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-0001")
.WithAccessToken("accessToken-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeProbabilities(
new Gs2Lottery.DescribeProbabilitiesRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withAccessToken("accessToken-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_probabilities(
lottery.DescribeProbabilitiesRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_access_token('accessToken-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_probabilities({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
accessToken="accessToken-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('lottery')
api_result_handler = client.describe_probabilities_async({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
accessToken="accessToken-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describeProbabilitiesByUserId
List Draw Probabilities by User ID
The normal lottery responds with the same probability for all game players.
The box draw responds with a different probability for each game player, taking into account the remaining contents of the box.
#### 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 (.). |
| lotteryName | string | | ✓| | ~ 128 chars | Lottery Model name
Unique Lottery Model name. Specified using alphanumeric characters, hyphen (-), underscore (_), and period (.). |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<Probability>](#probability) | List of draw probabilities |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeProbabilitiesByUserId(
&lottery.DescribeProbabilitiesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lottery-0001"),
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeProbabilitiesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeProbabilitiesByUserId(
(new DescribeProbabilitiesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lottery-0001")
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeProbabilitiesByUserIdRequest;
import io.gs2.lottery.result.DescribeProbabilitiesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeProbabilitiesByUserIdResult result = client.describeProbabilitiesByUserId(
new DescribeProbabilitiesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeProbabilitiesByUserId(
new Gs2.Gs2Lottery.Request.DescribeProbabilitiesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lottery-0001")
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeProbabilitiesByUserId(
new Gs2Lottery.DescribeProbabilitiesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lottery-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_probabilities_by_user_id(
lottery.DescribeProbabilitiesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lottery-0001')
.with_user_id('user-0001')
.with_time_offset_token(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_probabilities_by_user_id({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.describe_probabilities_by_user_id_async({
namespaceName="namespace-0001",
lotteryName="lottery-0001",
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describePrizeLimits
List Prize Limits
Retrieves a paginated list of prize draw count limits for the specified Prize Table.
Prize limits track how many times each prize has been drawn, enabling limited-quantity prize configurations.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table name
Unique Prize Table name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<PrizeLimit>](#prizelimit) | List of Prize Limits |
| 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribePrizeLimits(
&lottery.DescribePrizeLimitsRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribePrizeLimitsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describePrizeLimits(
(new DescribePrizeLimitsRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribePrizeLimitsRequest;
import io.gs2.lottery.result.DescribePrizeLimitsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribePrizeLimitsResult result = client.describePrizeLimits(
new DescribePrizeLimitsRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribePrizeLimits(
new Gs2.Gs2Lottery.Request.DescribePrizeLimitsRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describePrizeLimits(
new Gs2Lottery.DescribePrizeLimitsRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_prize_limits(
lottery.DescribePrizeLimitsRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-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('lottery')
api_result = client.describe_prize_limits({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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('lottery')
api_result_handler = client.describe_prize_limits_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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;
```
---
### getPrizeLimit
Get Prize Limit
Retrieves the current draw count for a specific prize in the Prize Table.
This shows how many times the prize has been drawn against its configured limit.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table name
Unique Prize Table name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| prizeId | string | | ✓| UUID | ~ 36 chars | Prize ID
A unique identifier for this prize within the Prize Table. Used to track draw limits and as a reference when specifying failover prizes. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [PrizeLimit](#prizelimit) | Prize Limit |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetPrizeLimit(
&lottery.GetPrizeLimitRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
PrizeId: pointy.String("prize-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetPrizeLimitRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getPrizeLimit(
(new GetPrizeLimitRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withPrizeId("prize-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetPrizeLimitRequest;
import io.gs2.lottery.result.GetPrizeLimitResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetPrizeLimitResult result = client.getPrizeLimit(
new GetPrizeLimitRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withPrizeId("prize-0001")
);
PrizeLimit 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetPrizeLimit(
new Gs2.Gs2Lottery.Request.GetPrizeLimitRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithPrizeId("prize-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getPrizeLimit(
new Gs2Lottery.GetPrizeLimitRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withPrizeId("prize-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_prize_limit(
lottery.GetPrizeLimitRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_prize_id('prize-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_prize_limit({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
prizeId="prize-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('lottery')
api_result_handler = client.get_prize_limit_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
prizeId="prize-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;
```
---
### resetPrizeLimit
Reset Prize Limit
Resets the draw count for a specific prize by deleting the prize limit record.
After reset, the prize becomes available for drawing again up to its configured limit.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table name
Unique Prize Table name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| prizeId | string | | ✓| UUID | ~ 36 chars | Prize ID
A unique identifier for this prize within the Prize Table. Used to track draw limits and as a reference when specifying failover prizes. |
#### Result
| | Type | Description |
| --- | --- | --- |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.ResetPrizeLimit(
&lottery.ResetPrizeLimitRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
PrizeId: pointy.String("prize-0001"),
}
)
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\ResetPrizeLimitRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->resetPrizeLimit(
(new ResetPrizeLimitRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withPrizeId("prize-0001")
);
} 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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.ResetPrizeLimitRequest;
import io.gs2.lottery.result.ResetPrizeLimitResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
ResetPrizeLimitResult result = client.resetPrizeLimit(
new ResetPrizeLimitRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withPrizeId("prize-0001")
);
} 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.ResetPrizeLimit(
new Gs2.Gs2Lottery.Request.ResetPrizeLimitRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithPrizeId("prize-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.resetPrizeLimit(
new Gs2Lottery.ResetPrizeLimitRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withPrizeId("prize-0001")
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.reset_prize_limit(
lottery.ResetPrizeLimitRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_prize_id('prize-0001')
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.reset_prize_limit({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
prizeId="prize-0001",
})
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('lottery')
api_result_handler = client.reset_prize_limit_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
prizeId="prize-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
```
---
### describeBoxes
List items extracted from the box
Retrieves a paginated list of box states for all box-mode lottery models in the Namespace.
Each entry shows which prizes have been drawn from the box and their remaining quantities.
If a box has not yet been drawn, an empty box state is created and returned.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<BoxItems>](#boxitems) | List of box states |
| 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeBoxes(
&lottery.DescribeBoxesRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
PageToken: nil,
Limit: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeBoxesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeBoxes(
(new DescribeBoxesRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withPageToken(null)
->withLimit(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeBoxesRequest;
import io.gs2.lottery.result.DescribeBoxesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeBoxesResult result = client.describeBoxes(
new DescribeBoxesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withPageToken(null)
.withLimit(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeBoxes(
new Gs2.Gs2Lottery.Request.DescribeBoxesRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithPageToken(null)
.WithLimit(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeBoxes(
new Gs2Lottery.DescribeBoxesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withPageToken(null)
.withLimit(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_boxes(
lottery.DescribeBoxesRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_page_token(None)
.with_limit(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_boxes({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
pageToken=nil,
limit=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.describe_boxes_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
pageToken=nil,
limit=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### describeBoxesByUserId
List boxes by User ID
Retrieves a paginated list of box states for the specified user across all box-mode lottery models.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| userId | string | | ✓| | ~ 128 chars | User ID |
| pageToken | string | | | | ~ 1024 chars | Token specifying the position from which to start acquiring data |
| limit | int | | | 30 | 1 ~ 1000 | Number of data items to retrieve |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<BoxItems>](#boxitems) | List of box states |
| 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeBoxesByUserId(
&lottery.DescribeBoxesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
PageToken: nil,
Limit: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
nextPageToken := result.NextPageToken
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeBoxesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeBoxesByUserId(
(new DescribeBoxesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withPageToken(null)
->withLimit(null)
->withTimeOffsetToken(null)
);
$items = $result->getItems();
$nextPageToken = $result->getNextPageToken();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeBoxesByUserIdRequest;
import io.gs2.lottery.result.DescribeBoxesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeBoxesByUserIdResult result = client.describeBoxesByUserId(
new DescribeBoxesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
List items = result.getItems();
String nextPageToken = result.getNextPageToken();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeBoxesByUserId(
new Gs2.Gs2Lottery.Request.DescribeBoxesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithPageToken(null)
.WithLimit(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
var nextPageToken = result.NextPageToken;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeBoxesByUserId(
new Gs2Lottery.DescribeBoxesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withPageToken(null)
.withLimit(null)
.withTimeOffsetToken(null)
);
const items = result.getItems();
const nextPageToken = result.getNextPageToken();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_boxes_by_user_id(
lottery.DescribeBoxesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_page_token(None)
.with_limit(None)
.with_time_offset_token(None)
)
items = result.items
next_page_token = result.next_page_token
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_boxes_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
pageToken=nil,
limit=nil,
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.describe_boxes_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
pageToken=nil,
limit=nil,
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
nextPageToken = result.nextPageToken;
```
---
### getBox
Get Box
Retrieves the box state for a specific Prize Table, showing which prizes have been drawn and their remaining quantities.
If the box does not exist yet, an empty box state is created and returned.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table name |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | Box state including prizes and their remaining quantities |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetBox(
&lottery.GetBoxRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
AccessToken: pointy.String("accessToken-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetBoxRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getBox(
(new GetBoxRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withAccessToken("accessToken-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetBoxRequest;
import io.gs2.lottery.result.GetBoxResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetBoxResult result = client.getBox(
new GetBoxRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withAccessToken("accessToken-0001")
);
BoxItems 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetBox(
new Gs2.Gs2Lottery.Request.GetBoxRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithAccessToken("accessToken-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getBox(
new Gs2Lottery.GetBoxRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_box(
lottery.GetBoxRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_box({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
accessToken="accessToken-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.get_box_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
accessToken="accessToken-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getBoxByUserId
Get Box by User ID
Retrieves the box state for a specific Prize Table and user, showing drawn prizes and remaining quantities.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table name |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | Box state including prizes and their remaining quantities |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetBoxByUserId(
&lottery.GetBoxByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetBoxByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getBoxByUserId(
(new GetBoxByUserIdRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetBoxByUserIdRequest;
import io.gs2.lottery.result.GetBoxByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetBoxByUserIdResult result = client.getBoxByUserId(
new GetBoxByUserIdRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
BoxItems 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetBoxByUserId(
new Gs2.Gs2Lottery.Request.GetBoxByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getBoxByUserId(
new Gs2Lottery.GetBoxByUserIdRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_box_by_user_id(
lottery.GetBoxByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_user_id('user-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_box_by_user_id({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.get_box_by_user_id_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### resetBox
Reset Box
Resets the box to its initial state, returning all drawn prizes back into the box.
After reset, all prizes become available for drawing again.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table name |
| accessToken | string | | ✓| | ~ 128 chars | Access token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | Box state including prizes and their initial quantities |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.ResetBox(
&lottery.ResetBoxRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
AccessToken: pointy.String("accessToken-0001"),
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\ResetBoxRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->resetBox(
(new ResetBoxRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withAccessToken("accessToken-0001")
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.ResetBoxRequest;
import io.gs2.lottery.result.ResetBoxResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
ResetBoxResult result = client.resetBox(
new ResetBoxRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withAccessToken("accessToken-0001")
);
BoxItems 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.ResetBox(
new Gs2.Gs2Lottery.Request.ResetBoxRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithAccessToken("accessToken-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.resetBox(
new Gs2Lottery.ResetBoxRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withAccessToken("accessToken-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.reset_box(
lottery.ResetBoxRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_access_token('accessToken-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.reset_box({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
accessToken="accessToken-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.reset_box_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
accessToken="accessToken-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### resetBoxByUserId
Reset box with specified user ID
Resets the specified user's box to its initial state, returning all drawn prizes back into the box.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table name |
| userId | string | | ✓| | ~ 128 chars | User ID |
| timeOffsetToken | string | | | | ~ 1024 chars | Time offset token |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | Box state including prizes and their initial quantities |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.ResetBoxByUserId(
&lottery.ResetBoxByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\ResetBoxByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->resetBoxByUserId(
(new ResetBoxByUserIdRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.ResetBoxByUserIdRequest;
import io.gs2.lottery.result.ResetBoxByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
ResetBoxByUserIdResult result = client.resetBoxByUserId(
new ResetBoxByUserIdRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
BoxItems 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.ResetBoxByUserId(
new Gs2.Gs2Lottery.Request.ResetBoxByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.resetBoxByUserId(
new Gs2Lottery.ResetBoxByUserIdRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.reset_box_by_user_id(
lottery.ResetBoxByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_user_id('user-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.reset_box_by_user_id({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('lottery')
api_result_handler = client.reset_box_by_user_id_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeLotteryModels
List Lottery Models
Retrieves the list of currently active lottery models for the specified Namespace.
The models define the lottery mode (normal or box), draw method (Prize Table or script), and associated Prize Table configuration.
#### 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<LotteryModel>](#lotterymodel) | List of Lottery Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeLotteryModels(
&lottery.DescribeLotteryModelsRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeLotteryModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeLotteryModels(
(new DescribeLotteryModelsRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeLotteryModelsRequest;
import io.gs2.lottery.result.DescribeLotteryModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeLotteryModelsResult result = client.describeLotteryModels(
new DescribeLotteryModelsRequest()
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeLotteryModels(
new Gs2.Gs2Lottery.Request.DescribeLotteryModelsRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeLotteryModels(
new Gs2Lottery.DescribeLotteryModelsRequest()
.withNamespaceName("namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_lottery_models(
lottery.DescribeLotteryModelsRequest()
.with_namespace_name('namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.describe_lottery_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('lottery')
api_result_handler = client.describe_lottery_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;
```
---
### getLotteryModel
Get Lottery Model
Retrieves the specified lottery model, including its mode (normal/box), draw method (Prize Table/script), and Prize Table name.
#### 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 (.). |
| lotteryName | string | | ✓| | ~ 128 chars | Lottery Model name
Unique Lottery Model name. Specified using alphanumeric characters, hyphen (-), underscore (_), and period (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [LotteryModel](#lotterymodel) | Lottery Model |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetLotteryModel(
&lottery.GetLotteryModelRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lotteryModel-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetLotteryModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getLotteryModel(
(new GetLotteryModelRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lotteryModel-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetLotteryModelRequest;
import io.gs2.lottery.result.GetLotteryModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetLotteryModelResult result = client.getLotteryModel(
new GetLotteryModelRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
LotteryModel 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetLotteryModel(
new Gs2.Gs2Lottery.Request.GetLotteryModelRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lotteryModel-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getLotteryModel(
new Gs2Lottery.GetLotteryModelRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_lottery_model(
lottery.GetLotteryModelRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lotteryModel-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_lottery_model({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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('lottery')
api_result_handler = client.get_lottery_model_async({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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 Lottery Model Master in a master data format that can be activated
Exports the currently active lottery model masters in a format suitable for activation.
The exported data can be used to update master data in another Namespace or stored as a backup.
#### 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 | [CurrentLotteryMaster](#currentlotterymaster) | Lottery 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.ExportMaster(
&lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\ExportMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.ExportMasterRequest;
import io.gs2.lottery.result.ExportMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
ExportMasterResult result = client.exportMaster(
new ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentLotteryMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExportMaster(
new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.exportMaster(
new Gs2Lottery.ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.export_master(
lottery.ExportMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
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('lottery')
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;
```
---
### getCurrentLotteryMaster
Get currently active Lottery Model master data
Retrieves the currently active lottery model master data for the specified Namespace.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CurrentLotteryMaster](#currentlotterymaster) | Currently Active Lottery Model Master Data |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetCurrentLotteryMaster(
&lottery.GetCurrentLotteryMasterRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetCurrentLotteryMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getCurrentLotteryMaster(
(new GetCurrentLotteryMasterRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetCurrentLotteryMasterRequest;
import io.gs2.lottery.result.GetCurrentLotteryMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetCurrentLotteryMasterResult result = client.getCurrentLotteryMaster(
new GetCurrentLotteryMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentLotteryMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCurrentLotteryMaster(
new Gs2.Gs2Lottery.Request.GetCurrentLotteryMasterRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getCurrentLotteryMaster(
new Gs2Lottery.GetCurrentLotteryMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_current_lottery_master(
lottery.GetCurrentLotteryMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_current_lottery_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('lottery')
api_result_handler = client.get_current_lottery_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;
```
---
### preUpdateCurrentLotteryMaster
Update Currently Active Lottery 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 UpdateCurrentLotteryMaster 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.PreUpdateCurrentLotteryMaster(
&lottery.PreUpdateCurrentLotteryMasterRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\PreUpdateCurrentLotteryMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->preUpdateCurrentLotteryMaster(
(new PreUpdateCurrentLotteryMasterRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.PreUpdateCurrentLotteryMasterRequest;
import io.gs2.lottery.result.PreUpdateCurrentLotteryMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
PreUpdateCurrentLotteryMasterResult result = client.preUpdateCurrentLotteryMaster(
new PreUpdateCurrentLotteryMasterRequest()
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.PreUpdateCurrentLotteryMaster(
new Gs2.Gs2Lottery.Request.PreUpdateCurrentLotteryMasterRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.preUpdateCurrentLotteryMaster(
new Gs2Lottery.PreUpdateCurrentLotteryMasterRequest()
.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.pre_update_current_lottery_master(
lottery.PreUpdateCurrentLotteryMasterRequest()
.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('lottery')
api_result = client.pre_update_current_lottery_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('lottery')
api_result_handler = client.pre_update_current_lottery_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;
```
---
### updateCurrentLotteryMaster
Update Currently Active Lottery Model Master Data
Updates the currently active lottery model master data.
Supports two modes: 'direct' for inline settings, and 'preUpload' for applying settings previously uploaded via the 3-phase update process.
#### Request
| | Type | Condition | Required | Default | Value Limits | Description |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128 chars | Namespace name
Unique Namespace name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| mode | string (enum)
enum {
"direct",
"preUpload"
}
| | | "direct" | | Update mode"direct": Directly update master data / "preUpload": Upload master data and then update / |
| settings | string | {mode} == "direct" | ✓*| | ~ 5242880 bytes (5MB) | Master Data
* Required if mode is "direct" |
| uploadToken | string | {mode} == "preUpload" | ✓*| | ~ 1024 chars | Token obtained by pre-upload
Used to apply the uploaded master data.
* Required if mode is "preUpload" |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [CurrentLotteryMaster](#currentlotterymaster) | Updated current active Lottery Model master data |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.UpdateCurrentLotteryMaster(
&lottery.UpdateCurrentLotteryMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Mode: pointy.String("direct"),
Settings: pointy.String("{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\n }\n ]\n}"),
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\UpdateCurrentLotteryMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->updateCurrentLotteryMaster(
(new UpdateCurrentLotteryMasterRequest())
->withNamespaceName("namespace-0001")
->withMode("direct")
->withSettings("{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\n }\n ]\n}")
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.UpdateCurrentLotteryMasterRequest;
import io.gs2.lottery.result.UpdateCurrentLotteryMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
UpdateCurrentLotteryMasterResult result = client.updateCurrentLotteryMaster(
new UpdateCurrentLotteryMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\n }\n ]\n}")
.withUploadToken(null)
);
CurrentLotteryMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentLotteryMaster(
new Gs2.Gs2Lottery.Request.UpdateCurrentLotteryMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMode("direct")
.WithSettings("{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\n }\n ]\n}")
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.updateCurrentLotteryMaster(
new Gs2Lottery.UpdateCurrentLotteryMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\n }\n ]\n}")
.withUploadToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.update_current_lottery_master(
lottery.UpdateCurrentLotteryMasterRequest()
.with_namespace_name('namespace-0001')
.with_mode('direct')
.with_settings('{\n "version": "2019-02-21",\n "lotteryModels": [\n {\n "name": "gacha",\n "metadata": "GACHA",\n "mode": "normal",\n "method": "prize_table",\n "prizeTableName": "gacha"\n },\n {\n "name": "gacha_ssr",\n "metadata": "SSR",\n "mode": "normal",\n "method": "prize_table",\n "prizeTableName": "gacha-ssr"\n },\n {\n "name": "gacha_sr",\n "metadata": "SR",\n "mode": "normal",\n "method": "prize_table",\n "prizeTableName": "gacha-sr"\n },\n {\n "name": "gacha_r",\n "metadata": "R",\n "mode": "normal",\n "method": "prize_table",\n "prizeTableName": "gacha-r"\n },\n {\n "name": "box",\n "metadata": "BOX",\n "mode": "box",\n "method": "prize_table",\n "prizeTableName": "box"\n }\n ],\n "prizeTables": [\n {\n "name": "gacha",\n "metadata": "SSR",\n "prizes": [\n {\n "prizeId": "prize-1",\n "type": "prize_table",\n "prizeTableName": "gacha-ssr",\n "weight": 5\n },\n {\n "prizeId": "prize-2",\n "type": "prize_table",\n "prizeTableName": "gacha-sr",\n "weight": 15\n },\n {\n "prizeId": "prize-3",\n "type": "prize_table",\n "prizeTableName": "gacha-r",\n "weight": 80\n }\n ]\n },\n {\n "name": "gacha-ssr",\n "metadata": "SSR",\n "prizes": [\n {\n "prizeId": "prize-4",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 1\n },\n {\n "prizeId": "prize-5",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 2\n },\n {\n "prizeId": "prize-6",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 3\n }\n ]\n },\n {\n "name": "gacha-sr",\n "metadata": "SR",\n "prizes": [\n {\n "prizeId": "prize-7",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 10\n },\n {\n "prizeId": "prize-8",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 20\n },\n {\n "prizeId": "prize-9",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 30\n }\n ]\n },\n {\n "name": "gacha-r",\n "metadata": "R",\n "prizes": [\n {\n "prizeId": "prize-10",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 100\n },\n {\n "prizeId": "prize-11",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 200\n },\n {\n "prizeId": "prize-12",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 300\n }\n ]\n },\n {\n "name": "box",\n "metadata": "BOX",\n "prizes": [\n {\n "prizeId": "prize-13",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 30\n },\n {\n "prizeId": "prize-14",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 20\n },\n {\n "prizeId": "prize-15",\n "type": "action",\n "acquireActions": [\n {\n "action": "Gs2Money:DepositByUserId",\n "request": "{\\"count\\": 1}"\n }\n ],\n "weight": 10\n }\n ]\n }\n ]\n}')
.with_upload_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.update_current_lottery_master({
namespaceName="namespace-0001",
mode="direct",
settings="{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\n }\n ]\n}",
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('lottery')
api_result_handler = client.update_current_lottery_master_async({
namespaceName="namespace-0001",
mode="direct",
settings="{\n \"version\": \"2019-02-21\",\n \"lotteryModels\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"GACHA\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha\"\n },\n {\n \"name\": \"gacha_ssr\",\n \"metadata\": \"SSR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\"\n },\n {\n \"name\": \"gacha_sr\",\n \"metadata\": \"SR\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\"\n },\n {\n \"name\": \"gacha_r\",\n \"metadata\": \"R\",\n \"mode\": \"normal\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\"\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"mode\": \"box\",\n \"method\": \"prize_table\",\n \"prizeTableName\": \"box\"\n }\n ],\n \"prizeTables\": [\n {\n \"name\": \"gacha\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-1\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-ssr\",\n \"weight\": 5\n },\n {\n \"prizeId\": \"prize-2\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-sr\",\n \"weight\": 15\n },\n {\n \"prizeId\": \"prize-3\",\n \"type\": \"prize_table\",\n \"prizeTableName\": \"gacha-r\",\n \"weight\": 80\n }\n ]\n },\n {\n \"name\": \"gacha-ssr\",\n \"metadata\": \"SSR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-4\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 1\n },\n {\n \"prizeId\": \"prize-5\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 2\n },\n {\n \"prizeId\": \"prize-6\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 3\n }\n ]\n },\n {\n \"name\": \"gacha-sr\",\n \"metadata\": \"SR\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-7\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n },\n {\n \"prizeId\": \"prize-8\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-9\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n }\n ]\n },\n {\n \"name\": \"gacha-r\",\n \"metadata\": \"R\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-10\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 100\n },\n {\n \"prizeId\": \"prize-11\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 200\n },\n {\n \"prizeId\": \"prize-12\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 300\n }\n ]\n },\n {\n \"name\": \"box\",\n \"metadata\": \"BOX\",\n \"prizes\": [\n {\n \"prizeId\": \"prize-13\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 30\n },\n {\n \"prizeId\": \"prize-14\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 20\n },\n {\n \"prizeId\": \"prize-15\",\n \"type\": \"action\",\n \"acquireActions\": [\n {\n \"action\": \"Gs2Money:DepositByUserId\",\n \"request\": \"{\\\"count\\\": 1}\"\n }\n ],\n \"weight\": 10\n }\n ]\n }\n ]\n}",
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;
```
---
### updateCurrentLotteryMasterFromGitHub
Update Currently Active Lottery Model Master Data from GitHub
Updates the currently active lottery model master data by fetching it from a specified GitHub repository.
The API key stored in GS2-Key is used for authentication, and you can specify the branch, tag, or commit hash to checkout.
#### 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 | [CurrentLotteryMaster](#currentlotterymaster) | Updated current active Lottery Model master data |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.UpdateCurrentLotteryMasterFromGitHub(
&lottery.UpdateCurrentLotteryMasterFromGitHubRequest {
NamespaceName: pointy.String("namespace-0001"),
CheckoutSetting: &lottery.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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\UpdateCurrentLotteryMasterFromGitHubRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->updateCurrentLotteryMasterFromGitHub(
(new UpdateCurrentLotteryMasterFromGitHubRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.UpdateCurrentLotteryMasterFromGitHubRequest;
import io.gs2.lottery.result.UpdateCurrentLotteryMasterFromGitHubResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
UpdateCurrentLotteryMasterFromGitHubResult result = client.updateCurrentLotteryMasterFromGitHub(
new UpdateCurrentLotteryMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
CurrentLotteryMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentLotteryMasterFromGitHub(
new Gs2.Gs2Lottery.Request.UpdateCurrentLotteryMasterFromGitHubRequest()
.WithNamespaceName("namespace-0001")
.WithCheckoutSetting(new Gs2.Gs2Lottery.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.updateCurrentLotteryMasterFromGitHub(
new Gs2Lottery.UpdateCurrentLotteryMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new Gs2Lottery.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.update_current_lottery_master_from_git_hub(
lottery.UpdateCurrentLotteryMasterFromGitHubRequest()
.with_namespace_name('namespace-0001')
.with_checkout_setting(lottery.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('lottery')
api_result = client.update_current_lottery_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('lottery')
api_result_handler = client.update_current_lottery_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;
```
---
### describeLotteryModelMasters
List Lottery Model Masters
Retrieves a paginated list of lottery model masters for the specified Namespace.
Can optionally filter by name prefix.
#### 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 Lottery 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 items to retrieve |
#### Result
| | Type | Description |
| --- | --- | --- |
| items | [List<LotteryModelMaster>](#lotterymodelmaster) | List of Lottery Model Master |
| 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribeLotteryModelMasters(
&lottery.DescribeLotteryModelMastersRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribeLotteryModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describeLotteryModelMasters(
(new DescribeLotteryModelMastersRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribeLotteryModelMastersRequest;
import io.gs2.lottery.result.DescribeLotteryModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribeLotteryModelMastersResult result = client.describeLotteryModelMasters(
new DescribeLotteryModelMastersRequest()
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeLotteryModelMasters(
new Gs2.Gs2Lottery.Request.DescribeLotteryModelMastersRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describeLotteryModelMasters(
new Gs2Lottery.DescribeLotteryModelMastersRequest()
.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_lottery_model_masters(
lottery.DescribeLotteryModelMastersRequest()
.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('lottery')
api_result = client.describe_lottery_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('lottery')
api_result_handler = client.describe_lottery_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;
```
---
### createLotteryModelMaster
Create Lottery Model Master
Creates a new lottery model master with the specified configuration.
The mode can be 'normal' (standard lottery with replacement) or 'box' (lottery without replacement where drawn prizes are removed from the pool).
The method can be 'prizeTable' (using a predefined Prize Table) or 'script' (using a GS2-Script to determine prizes dynamically).
#### 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 | Lottery Model name
Unique Lottery Model name. Specified using alphanumeric characters, hyphen (-), underscore (_), and period (.). |
| 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. |
| mode | string (enum)
enum {
"normal",
"box"
}
| | ✓| | | Drawing Mode
Select the prize drawing method. "normal" performs draws with a fixed probability each time (prizes can be drawn repeatedly). "box" places a predetermined number of prizes in a virtual box, and each draw removes a prize from the box (guaranteeing all prizes will eventually be drawn)."normal": Normal Draw / "box": Box Draw / |
| method | string (enum)
enum {
"prize_table",
"script"
}
| | ✓| | | Prize Table Selection Method
Determines how the Prize Table is referenced. "prize_table" uses a statically specified Prize Table.
"script" uses GS2-Script to dynamically select the Prize Table at draw time, enabling scenarios such as applying a different drop probability table just once during a 10-draw gacha."prize_table": Static Prize Table / "script": Dynamically selected Prize Table using GS2-Script / |
| prizeTableName | string | {method} == "prize_table" | ✓*| | ~ 128 chars | Prize Table Name
The name of the Prize Table to use for this lottery model. Required when the lottery method is "prize_table".
* Required if method is "prize_table" |
| choicePrizeTableScriptId | string | {method} == "script" | ✓*| | ~ 1024 chars | GS2-Script script GRN to determine the Prize Table
Script Trigger Reference - [`choicePrizeTable`](../script/#choiceprizetable)
* Required if method is "script" |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | Lottery Model Master created |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CreateLotteryModelMaster(
&lottery.CreateLotteryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("lotteryModel-0001"),
Description: nil,
Metadata: nil,
Mode: pointy.String("normal"),
Method: pointy.String("prize_table"),
PrizeTableName: pointy.String("prizeTable-0001"),
ChoicePrizeTableScriptId: 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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CreateLotteryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->createLotteryModelMaster(
(new CreateLotteryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withName("lotteryModel-0001")
->withDescription(null)
->withMetadata(null)
->withMode("normal")
->withMethod("prize_table")
->withPrizeTableName("prizeTable-0001")
->withChoicePrizeTableScriptId(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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CreateLotteryModelMasterRequest;
import io.gs2.lottery.result.CreateLotteryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
CreateLotteryModelMasterResult result = client.createLotteryModelMaster(
new CreateLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("lotteryModel-0001")
.withDescription(null)
.withMetadata(null)
.withMode("normal")
.withMethod("prize_table")
.withPrizeTableName("prizeTable-0001")
.withChoicePrizeTableScriptId(null)
);
LotteryModelMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateLotteryModelMaster(
new Gs2.Gs2Lottery.Request.CreateLotteryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("lotteryModel-0001")
.WithDescription(null)
.WithMetadata(null)
.WithMode("normal")
.WithMethod("prize_table")
.WithPrizeTableName("prizeTable-0001")
.WithChoicePrizeTableScriptId(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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.createLotteryModelMaster(
new Gs2Lottery.CreateLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("lotteryModel-0001")
.withDescription(null)
.withMetadata(null)
.withMode("normal")
.withMethod("prize_table")
.withPrizeTableName("prizeTable-0001")
.withChoicePrizeTableScriptId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.create_lottery_model_master(
lottery.CreateLotteryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('lotteryModel-0001')
.with_description(None)
.with_metadata(None)
.with_mode('normal')
.with_method('prize_table')
.with_prize_table_name('prizeTable-0001')
.with_choice_prize_table_script_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.create_lottery_model_master({
namespaceName="namespace-0001",
name="lotteryModel-0001",
description=nil,
metadata=nil,
mode="normal",
method="prize_table",
prizeTableName="prizeTable-0001",
choicePrizeTableScriptId=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('lottery')
api_result_handler = client.create_lottery_model_master_async({
namespaceName="namespace-0001",
name="lotteryModel-0001",
description=nil,
metadata=nil,
mode="normal",
method="prize_table",
prizeTableName="prizeTable-0001",
choicePrizeTableScriptId=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;
```
---
### getLotteryModelMaster
Get Lottery Model Master
Retrieves the specified lottery model master, including its mode (normal/box), draw method (prizeTable/script), and associated Prize Table or script configuration.
#### 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 (.). |
| lotteryName | string | | ✓| | ~ 128 chars | Lottery Model name
Unique Lottery Model name. Specified using alphanumeric characters, hyphen (-), underscore (_), and period (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | Lottery Model Master |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetLotteryModelMaster(
&lottery.GetLotteryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lotteryModel-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetLotteryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getLotteryModelMaster(
(new GetLotteryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lotteryModel-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetLotteryModelMasterRequest;
import io.gs2.lottery.result.GetLotteryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetLotteryModelMasterResult result = client.getLotteryModelMaster(
new GetLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
LotteryModelMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetLotteryModelMaster(
new Gs2.Gs2Lottery.Request.GetLotteryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lotteryModel-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getLotteryModelMaster(
new Gs2Lottery.GetLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_lottery_model_master(
lottery.GetLotteryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lotteryModel-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_lottery_model_master({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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('lottery')
api_result_handler = client.get_lottery_model_master_async({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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;
```
---
### updateLotteryModelMaster
Update Lottery Model Master
Updates the specified lottery model master. You can modify the description, metadata, mode (normal/box), draw method (prizeTable/script), Prize Table name, and script 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 (.). |
| lotteryName | string | | ✓| | ~ 128 chars | Lottery Model name
Unique Lottery Model name. Specified using alphanumeric characters, hyphen (-), underscore (_), and period (.). |
| 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. |
| mode | string (enum)
enum {
"normal",
"box"
}
| | ✓| | | Drawing Mode
Select the prize drawing method. "normal" performs draws with a fixed probability each time (prizes can be drawn repeatedly). "box" places a predetermined number of prizes in a virtual box, and each draw removes a prize from the box (guaranteeing all prizes will eventually be drawn)."normal": Normal Draw / "box": Box Draw / |
| method | string (enum)
enum {
"prize_table",
"script"
}
| | ✓| | | Prize Table Selection Method
Determines how the Prize Table is referenced. "prize_table" uses a statically specified Prize Table.
"script" uses GS2-Script to dynamically select the Prize Table at draw time, enabling scenarios such as applying a different drop probability table just once during a 10-draw gacha."prize_table": Static Prize Table / "script": Dynamically selected Prize Table using GS2-Script / |
| prizeTableName | string | {method} == "prize_table" | ✓*| | ~ 128 chars | Prize Table Name
The name of the Prize Table to use for this lottery model. Required when the lottery method is "prize_table".
* Required if method is "prize_table" |
| choicePrizeTableScriptId | string | {method} == "script" | ✓*| | ~ 1024 chars | GS2-Script script GRN to determine the Prize Table
Script Trigger Reference - [`choicePrizeTable`](../script/#choiceprizetable)
* Required if method is "script" |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | Lottery Model Master updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.UpdateLotteryModelMaster(
&lottery.UpdateLotteryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lotteryModel-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("METADATA1"),
Mode: pointy.String("box"),
Method: pointy.String("prize_table"),
PrizeTableName: pointy.String("prizeTable-0002"),
ChoicePrizeTableScriptId: 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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\UpdateLotteryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->updateLotteryModelMaster(
(new UpdateLotteryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lotteryModel-0001")
->withDescription("description1")
->withMetadata("METADATA1")
->withMode("box")
->withMethod("prize_table")
->withPrizeTableName("prizeTable-0002")
->withChoicePrizeTableScriptId(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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.UpdateLotteryModelMasterRequest;
import io.gs2.lottery.result.UpdateLotteryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
UpdateLotteryModelMasterResult result = client.updateLotteryModelMaster(
new UpdateLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
.withDescription("description1")
.withMetadata("METADATA1")
.withMode("box")
.withMethod("prize_table")
.withPrizeTableName("prizeTable-0002")
.withChoicePrizeTableScriptId(null)
);
LotteryModelMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateLotteryModelMaster(
new Gs2.Gs2Lottery.Request.UpdateLotteryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lotteryModel-0001")
.WithDescription("description1")
.WithMetadata("METADATA1")
.WithMode("box")
.WithMethod("prize_table")
.WithPrizeTableName("prizeTable-0002")
.WithChoicePrizeTableScriptId(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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.updateLotteryModelMaster(
new Gs2Lottery.UpdateLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
.withDescription("description1")
.withMetadata("METADATA1")
.withMode("box")
.withMethod("prize_table")
.withPrizeTableName("prizeTable-0002")
.withChoicePrizeTableScriptId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.update_lottery_model_master(
lottery.UpdateLotteryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lotteryModel-0001')
.with_description('description1')
.with_metadata('METADATA1')
.with_mode('box')
.with_method('prize_table')
.with_prize_table_name('prizeTable-0002')
.with_choice_prize_table_script_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.update_lottery_model_master({
namespaceName="namespace-0001",
lotteryName="lotteryModel-0001",
description="description1",
metadata="METADATA1",
mode="box",
method="prize_table",
prizeTableName="prizeTable-0002",
choicePrizeTableScriptId=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('lottery')
api_result_handler = client.update_lottery_model_master_async({
namespaceName="namespace-0001",
lotteryName="lotteryModel-0001",
description="description1",
metadata="METADATA1",
mode="box",
method="prize_table",
prizeTableName="prizeTable-0002",
choicePrizeTableScriptId=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;
```
---
### deleteLotteryModelMaster
Delete Lottery Model Master
Deletes the specified lottery model master.
This does not affect the currently active master data until the next master data update.
#### 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 (.). |
| lotteryName | string | | ✓| | ~ 128 chars | Lottery Model name
Unique Lottery Model name. Specified using alphanumeric characters, hyphen (-), underscore (_), and period (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | Lottery Model Master deleted |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DeleteLotteryModelMaster(
&lottery.DeleteLotteryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
LotteryName: pointy.String("lotteryModel-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DeleteLotteryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->deleteLotteryModelMaster(
(new DeleteLotteryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withLotteryName("lotteryModel-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DeleteLotteryModelMasterRequest;
import io.gs2.lottery.result.DeleteLotteryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DeleteLotteryModelMasterResult result = client.deleteLotteryModelMaster(
new DeleteLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
LotteryModelMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteLotteryModelMaster(
new Gs2.Gs2Lottery.Request.DeleteLotteryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithLotteryName("lotteryModel-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.deleteLotteryModelMaster(
new Gs2Lottery.DeleteLotteryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withLotteryName("lotteryModel-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.delete_lottery_model_master(
lottery.DeleteLotteryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_lottery_name('lotteryModel-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.delete_lottery_model_master({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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('lottery')
api_result_handler = client.delete_lottery_model_master_async({
namespaceName="namespace-0001",
lotteryName="lotteryModel-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;
```
---
### describePrizeTableMasters
List Prize Table Masters
Retrieves a paginated list of Prize Table masters for the specified Namespace.
Can optionally filter by name prefix.
#### 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 Prize Table 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<PrizeTableMaster>](#prizetablemaster) | List of Prize Tables |
| 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/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DescribePrizeTableMasters(
&lottery.DescribePrizeTableMastersRequest {
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DescribePrizeTableMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->describePrizeTableMasters(
(new DescribePrizeTableMastersRequest())
->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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DescribePrizeTableMastersRequest;
import io.gs2.lottery.result.DescribePrizeTableMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DescribePrizeTableMastersResult result = client.describePrizeTableMasters(
new DescribePrizeTableMastersRequest()
.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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribePrizeTableMasters(
new Gs2.Gs2Lottery.Request.DescribePrizeTableMastersRequest()
.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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.describePrizeTableMasters(
new Gs2Lottery.DescribePrizeTableMastersRequest()
.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 lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.describe_prize_table_masters(
lottery.DescribePrizeTableMastersRequest()
.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('lottery')
api_result = client.describe_prize_table_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('lottery')
api_result_handler = client.describe_prize_table_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;
```
---
### createPrizeTableMaster
Create Prize Table Master
Creates a new Prize Table Master with the specified prizes configuration.
Each prize entry defines the prize ID, type, acquire actions, draw weight, and optional quantity limit.
#### 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 | Prize Table Name
Unique Prize Table name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| description | string | | | | ~ 1024 chars | Description |
| metadata | string | | | | ~ 128 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. |
| prizes | [List<Prize>](#prize) | | ✓| | 1 ~ 100 items | Prizes
The list of prizes in this Prize Table. Each prize defines its draw weight (probability), the actions to execute when drawn, and optionally a draw limit. The actual draw probability of each prize is calculated as its weight divided by the total weight of all prizes in the table. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | Prize Table Master created |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.CreatePrizeTableMaster(
&lottery.CreatePrizeTableMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("prizeTable-0001"),
Description: nil,
Metadata: nil,
Prizes: []lottery.Prize{
lottery.Prize{
PrizeId: pointy.String("1"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-0001"),
},
},
Weight: pointy.Int32(1),
},
lottery.Prize{
PrizeId: pointy.String("2"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-0002"),
},
},
Weight: pointy.Int32(2),
},
lottery.Prize{
PrizeId: pointy.String("3"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-0003"),
},
},
Weight: pointy.Int32(3),
},
},
}
)
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\CreatePrizeTableMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->createPrizeTableMaster(
(new CreatePrizeTableMasterRequest())
->withNamespaceName("namespace-0001")
->withName("prizeTable-0001")
->withDescription(null)
->withMetadata(null)
->withPrizes([
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("1")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-0001"),
])
->withWeight(1),
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("2")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-0002"),
])
->withWeight(2),
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("3")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-0003"),
])
->withWeight(3),
])
);
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.CreatePrizeTableMasterRequest;
import io.gs2.lottery.result.CreatePrizeTableMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
CreatePrizeTableMasterResult result = client.createPrizeTableMaster(
new CreatePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withName("prizeTable-0001")
.withDescription(null)
.withMetadata(null)
.withPrizes(Arrays.asList(
new io.gs2.lottery.model.Prize()
.withPrizeId("1")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0001")
))
.withWeight(1),
new io.gs2.lottery.model.Prize()
.withPrizeId("2")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0002")
))
.withWeight(2),
new io.gs2.lottery.model.Prize()
.withPrizeId("3")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0003")
))
.withWeight(3)
))
);
PrizeTableMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreatePrizeTableMaster(
new Gs2.Gs2Lottery.Request.CreatePrizeTableMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("prizeTable-0001")
.WithDescription(null)
.WithMetadata(null)
.WithPrizes(new Gs2.Gs2Lottery.Model.Prize[] {
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("1")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-0001"),
})
.WithWeight(1),
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("2")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-0002"),
})
.WithWeight(2),
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("3")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-0003"),
})
.WithWeight(3),
}),
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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.createPrizeTableMaster(
new Gs2Lottery.CreatePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withName("prizeTable-0001")
.withDescription(null)
.withMetadata(null)
.withPrizes([
new Gs2Lottery.model.Prize()
.withPrizeId("1")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0001"),
])
.withWeight(1),
new Gs2Lottery.model.Prize()
.withPrizeId("2")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0002"),
])
.withWeight(2),
new Gs2Lottery.model.Prize()
.withPrizeId("3")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-0003"),
])
.withWeight(3),
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.create_prize_table_master(
lottery.CreatePrizeTableMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('prizeTable-0001')
.with_description(None)
.with_metadata(None)
.with_prizes([
lottery.Prize()
.with_prize_id('1')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-0001'),
])
.with_weight(1),
lottery.Prize()
.with_prize_id('2')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-0002'),
])
.with_weight(2),
lottery.Prize()
.with_prize_id('3')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-0003'),
])
.with_weight(3),
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.create_prize_table_master({
namespaceName="namespace-0001",
name="prizeTable-0001",
description=nil,
metadata=nil,
prizes={
{
prizeId="1",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0001",
}
},
weight=1,
},
{
prizeId="2",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0002",
}
},
weight=2,
},
{
prizeId="3",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0003",
}
},
weight=3,
}
},
})
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('lottery')
api_result_handler = client.create_prize_table_master_async({
namespaceName="namespace-0001",
name="prizeTable-0001",
description=nil,
metadata=nil,
prizes={
{
prizeId="1",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0001",
}
},
weight=1,
},
{
prizeId="2",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0002",
}
},
weight=2,
},
{
prizeId="3",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-0003",
}
},
weight=3,
}
},
})
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;
```
---
### getPrizeTableMaster
Get Prize Table Master
Retrieves the specified Prize Table Master, including its list of prizes with their draw weights, types, and quantity limits.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table Name
Unique Prize Table name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | Prize Table Master |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.GetPrizeTableMaster(
&lottery.GetPrizeTableMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\GetPrizeTableMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->getPrizeTableMaster(
(new GetPrizeTableMasterRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.GetPrizeTableMasterRequest;
import io.gs2.lottery.result.GetPrizeTableMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
GetPrizeTableMasterResult result = client.getPrizeTableMaster(
new GetPrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
PrizeTableMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetPrizeTableMaster(
new Gs2.Gs2Lottery.Request.GetPrizeTableMasterRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.getPrizeTableMaster(
new Gs2Lottery.GetPrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.get_prize_table_master(
lottery.GetPrizeTableMasterRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.get_prize_table_master({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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('lottery')
api_result_handler = client.get_prize_table_master_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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;
```
---
### updatePrizeTableMaster
Update Prize Table Master
Updates the specified Prize Table Master. You can modify the description, metadata, and the list of prizes with their draw weights and quantity limits.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table Name
Unique Prize Table name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
| description | string | | | | ~ 1024 chars | Description |
| metadata | string | | | | ~ 128 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. |
| prizes | [List<Prize>](#prize) | | ✓| | 1 ~ 100 items | Prizes
The list of prizes in this Prize Table. Each prize defines its draw weight (probability), the actions to execute when drawn, and optionally a draw limit. The actual draw probability of each prize is calculated as its weight divided by the total weight of all prizes in the table. |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | Prize Table Master updated |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.UpdatePrizeTableMaster(
&lottery.UpdatePrizeTableMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("METADATA1"),
Prizes: []lottery.Prize{
lottery.Prize{
PrizeId: pointy.String("4"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-1001"),
},
},
Weight: pointy.Int32(2),
},
lottery.Prize{
PrizeId: pointy.String("5"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-1002"),
},
},
Weight: pointy.Int32(3),
},
lottery.Prize{
PrizeId: pointy.String("6"),
Type: pointy.String("action"),
AcquireActions: []lottery.AcquireAction{
lottery.AcquireAction{
Action: pointy.String("Gs2Money:DepositByUserId"),
Request: pointy.String("Gs2Money:DepositByUserId:request:ssr-1003"),
},
},
Weight: pointy.Int32(4),
},
},
}
)
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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\UpdatePrizeTableMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->updatePrizeTableMaster(
(new UpdatePrizeTableMasterRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-0001")
->withDescription("description1")
->withMetadata("METADATA1")
->withPrizes([
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("4")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-1001"),
])
->withWeight(2),
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("5")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-1002"),
])
->withWeight(3),
(new \Gs2\Lottery\Model\Prize())
->withPrizeId("6")
->withType("action")
->withAcquireActions([
(new \Gs2\Lottery\Model\AcquireAction())
->withAction("Gs2Money:DepositByUserId")
->withRequest("Gs2Money:DepositByUserId:request:ssr-1003"),
])
->withWeight(4),
])
);
$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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.UpdatePrizeTableMasterRequest;
import io.gs2.lottery.result.UpdatePrizeTableMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
UpdatePrizeTableMasterResult result = client.updatePrizeTableMaster(
new UpdatePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withDescription("description1")
.withMetadata("METADATA1")
.withPrizes(Arrays.asList(
new io.gs2.lottery.model.Prize()
.withPrizeId("4")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1001")
))
.withWeight(2),
new io.gs2.lottery.model.Prize()
.withPrizeId("5")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1002")
))
.withWeight(3),
new io.gs2.lottery.model.Prize()
.withPrizeId("6")
.withType("action")
.withAcquireActions(Arrays.asList(
new io.gs2.lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1003")
))
.withWeight(4)
))
);
PrizeTableMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdatePrizeTableMaster(
new Gs2.Gs2Lottery.Request.UpdatePrizeTableMasterRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-0001")
.WithDescription("description1")
.WithMetadata("METADATA1")
.WithPrizes(new Gs2.Gs2Lottery.Model.Prize[] {
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("4")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-1001"),
})
.WithWeight(2),
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("5")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-1002"),
})
.WithWeight(3),
new Gs2.Gs2Lottery.Model.Prize()
.WithPrizeId("6")
.WithType("action")
.WithAcquireActions(new Gs2.Core.Model.AcquireAction[] {
new Gs2.Core.Model.AcquireAction()
.WithAction("Gs2Money:DepositByUserId")
.WithRequest("Gs2Money:DepositByUserId:request:ssr-1003"),
})
.WithWeight(4),
}),
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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.updatePrizeTableMaster(
new Gs2Lottery.UpdatePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
.withDescription("description1")
.withMetadata("METADATA1")
.withPrizes([
new Gs2Lottery.model.Prize()
.withPrizeId("4")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1001"),
])
.withWeight(2),
new Gs2Lottery.model.Prize()
.withPrizeId("5")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1002"),
])
.withWeight(3),
new Gs2Lottery.model.Prize()
.withPrizeId("6")
.withType("action")
.withAcquireActions([
new Gs2Lottery.model.AcquireAction()
.withAction("Gs2Money:DepositByUserId")
.withRequest("Gs2Money:DepositByUserId:request:ssr-1003"),
])
.withWeight(4),
])
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.update_prize_table_master(
lottery.UpdatePrizeTableMasterRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
.with_description('description1')
.with_metadata('METADATA1')
.with_prizes([
lottery.Prize()
.with_prize_id('4')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-1001'),
])
.with_weight(2),
lottery.Prize()
.with_prize_id('5')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-1002'),
])
.with_weight(3),
lottery.Prize()
.with_prize_id('6')
.with_type('action')
.with_acquire_actions([
lottery.AcquireAction()
.with_action('Gs2Money:DepositByUserId')
.with_request('Gs2Money:DepositByUserId:request:ssr-1003'),
])
.with_weight(4),
])
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.update_prize_table_master({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
description="description1",
metadata="METADATA1",
prizes={
{
prizeId="4",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1001",
}
},
weight=2,
},
{
prizeId="5",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1002",
}
},
weight=3,
},
{
prizeId="6",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1003",
}
},
weight=4,
}
},
})
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('lottery')
api_result_handler = client.update_prize_table_master_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-0001",
description="description1",
metadata="METADATA1",
prizes={
{
prizeId="4",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1001",
}
},
weight=2,
},
{
prizeId="5",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1002",
}
},
weight=3,
},
{
prizeId="6",
type="action",
acquireActions={
{
action="Gs2Money:DepositByUserId",
request="Gs2Money:DepositByUserId:request:ssr-1003",
}
},
weight=4,
}
},
})
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;
```
---
### deletePrizeTableMaster
Delete Prize Table Master
Deletes the specified Prize Table Master.
This does not affect the currently active master data until the next master data update.
#### 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 (.). |
| prizeTableName | string | | ✓| | ~ 128 chars | Prize Table Name
Unique Prize Table name. Specified using alphanumeric characters, hyphens (-), underscores (_), and periods (.). |
#### Result
| | Type | Description |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | Prize Table Master deleted |
#### Implementation Example
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/lottery"
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 := lottery.Gs2LotteryRestClient{
Session: &session,
}
result, err := client.DeletePrizeTableMaster(
&lottery.DeletePrizeTableMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
PrizeTableName: pointy.String("prizeTable-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\Lottery\Gs2LotteryRestClient;
use Gs2\Lottery\Request\DeletePrizeTableMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2LotteryRestClient(
$session
);
try {
$result = $client->deletePrizeTableMaster(
(new DeletePrizeTableMasterRequest())
->withNamespaceName("namespace-0001")
->withPrizeTableName("prizeTable-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.lottery.rest.Gs2LotteryRestClient;
import io.gs2.lottery.request.DeletePrizeTableMasterRequest;
import io.gs2.lottery.result.DeletePrizeTableMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2LotteryRestClient client = new Gs2LotteryRestClient(session);
try {
DeletePrizeTableMasterResult result = client.deletePrizeTableMaster(
new DeletePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
PrizeTableMaster 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 Gs2LotteryRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeletePrizeTableMaster(
new Gs2.Gs2Lottery.Request.DeletePrizeTableMasterRequest()
.WithNamespaceName("namespace-0001")
.WithPrizeTableName("prizeTable-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 Gs2Lottery from '@/gs2/lottery';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Lottery.Gs2LotteryRestClient(session);
try {
const result = await client.deletePrizeTableMaster(
new Gs2Lottery.DeletePrizeTableMasterRequest()
.withNamespaceName("namespace-0001")
.withPrizeTableName("prizeTable-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import lottery
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = lottery.Gs2LotteryRestClient(session)
try:
result = client.delete_prize_table_master(
lottery.DeletePrizeTableMasterRequest()
.with_namespace_name('namespace-0001')
.with_prize_table_name('prizeTable-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('lottery')
api_result = client.delete_prize_table_master({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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('lottery')
api_result_handler = client.delete_prize_table_master_async({
namespaceName="namespace-0001",
prizeTableName="prizeTable-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;
```
---