> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Lottery SDK API 레퍼런스
각종 프로그래밍 언어용 GS2-Lottery SDK의 모델 사양과 API 레퍼런스
## 모델
### Namespace
네임스페이스
네임스페이스는 하나의 프로젝트 내에서 동일한 서비스를 서로 다른 용도로 여러 개 이용하기 위한 엔티티입니다.
GS2의 각 서비스는 네임스페이스 단위로 관리됩니다. 네임스페이스가 다르면 동일한 서비스라도 완전히 독립된 데이터 공간으로 취급됩니다.
따라서 각 서비스의 이용을 시작하려면 먼저 네임스페이스를 생성해야 합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024자 | 네임스페이스 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | ✓ | | | 트랜잭션 설정
추첨 조작 시 트랜잭션의 처리 방법을 제어하는 설정입니다. 추첨에서는 입수 액션을 통해 사용자에게 경품을 지급하는 트랜잭션이 발행됩니다. |
| lotteryTriggerScriptId | string | | | | ~ 1024자 | 추첨을 실행했을 때 호출되는 GS2-Script의 스크립트 GRN
Script 트리거 레퍼런스 - [`lottery`](../script/#lottery) |
| logSetting | [LogSetting](#logsetting) | | | | | 로그 출력 설정
추첨 조작의 API 요청·응답 로그를 출력하기 위한 GS2-Log 네임스페이스를 지정합니다. 디버그 및 분석을 위해 추첨 결과, 경품 배포, 박스 가챠 상태 추적에 유용합니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeNamespaces - 네임스페이스 목록 조회
createNamespace - 네임스페이스 신규 생성
getNamespace - 네임스페이스 조회
updateNamespace - 네임스페이스 갱신
deleteNamespace - 네임스페이스 삭제
---
### TransactionSetting
트랜잭션 설정
트랜잭션 설정은 트랜잭션의 실행 방법·정합성·비동기 처리·충돌 회피 메커니즘을 제어하는 설정입니다.
자동 실행(AutoRun), 원자적 실행(AtomicCommit), GS2-Distributor를 이용한 비동기 실행, 스크립트 결과의 일괄 적용, GS2-JobQueue를 통한 입수 액션의 비동기화 등을 조합하여 게임 로직에 맞는 견고한 트랜잭션 관리를 가능하게 합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| enableAutoRun | bool | | | false | | 발행한 트랜잭션을 서버 사이드에서 자동으로 실행할지 여부 |
| enableAtomicCommit | bool | {enableAutoRun} == true | | false | | 트랜잭션의 실행을 원자적으로 커밋할지 여부
※ enableAutoRun이(가) true 이면 활성화 |
| transactionUseDistributor | bool | {enableAtomicCommit} == true | | false | | 트랜잭션을 비동기 처리로 실행할지 여부
※ enableAtomicCommit이(가) true 이면 활성화 |
| commitScriptResultInUseDistributor | bool | {transactionUseDistributor} == true | | false | | 스크립트의 결과 커밋 처리를 비동기 처리로 실행할지 여부
※ transactionUseDistributor이(가) true 이면 활성화 |
| acquireActionUseJobQueue | bool | {enableAtomicCommit} == true | | false | | 입수 액션을 실행할 때 GS2-JobQueue를 사용할지 여부
※ enableAtomicCommit이(가) true 이면 활성화 |
| distributorNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:distributor:default" | ~ 1024자 | 트랜잭션 실행에 사용하는 GS2-Distributor 네임스페이스GRN |
| queueNamespaceId | string | | | "grn:gs2:{region}:{ownerId}:queue:default" | ~ 1024자 | 트랜잭션 실행에 사용하는 GS2-JobQueue의 네임스페이스GRN |
**관련 메서드:**
createNamespace - 네임스페이스 신규 생성
updateNamespace - 네임스페이스 갱신
**관련 모델:**
Namespace - 네임스페이스
---
### LogSetting
로그 출력 설정
로그 데이터의 출력 설정을 관리합니다. 이 타입은 로그 데이터를 출력하기 위해 사용되는 GS2-Log 네임스페이스의 식별자(Namespace ID)를 보관합니다.
로그 네임스페이스ID(loggingNamespaceId)에는 로그 데이터를 수집하여 저장하는 GS2-Log의 네임스페이스를 GRN 형식으로 지정합니다.
이 설정을 하면 설정된 네임스페이스 내에서 발생한 API 요청·응답 로그 데이터가 대상 GS2-Log 네임스페이스 쪽으로 출력됩니다.
GS2-Log에서는 실시간으로 로그가 제공되어 시스템 모니터링, 분석, 디버깅 등에 활용할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| loggingNamespaceId | string | | ✓ | | ~ 1024자 | 로그를 출력할 GS2-Log의 네임스페이스GRN
"grn:gs2:"로 시작하는 GRN 형식의 ID로 지정해야 합니다. |
**관련 메서드:**
createNamespace - 네임스페이스 신규 생성
updateNamespace - 네임스페이스 갱신
**관련 모델:**
Namespace - 네임스페이스
---
### GitHubCheckoutSetting
GitHub에서 마스터 데이터를 체크아웃하는 설정
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| apiKeyId | string | | ✓ | | ~ 1024자 | GitHub API 키의 GRN |
| repositoryName | string | | ✓ | | ~ 1024자 | 리포지토리 이름 |
| sourcePath | string | | ✓ | | ~ 1024자 | 마스터 데이터(JSON) 파일 경로 |
| referenceType | 문자열 열거형
enum {
"commit_hash",
"branch",
"tag"
}
| | ✓ | | | 코드 출처commit_hash: 커밋 해시 / branch: 브랜치 / tag: 태그 / |
| commitHash | string | {referenceType} == "commit_hash" | ✓※ | | ~ 1024자 | 커밋 해시
※ referenceType이(가) "commit_hash" 이면 필수 |
| branchName | string | {referenceType} == "branch" | ✓※ | | ~ 1024자 | 브랜치 이름
※ referenceType이(가) "branch" 이면 필수 |
| tagName | string | {referenceType} == "tag" | ✓※ | | ~ 1024자 | 태그 이름
※ referenceType이(가) "tag" 이면 필수 |
**관련 메서드:**
updateCurrentLotteryMasterFromGitHub - 현재 활성화된 추첨 모델 마스터 데이터를 GitHub에서 업데이트
---
### PrizeTable
배출 확률 테이블
경품에는 입수 액션을 직접 지정하거나, 다른 배출 확률 테이블을 참조하도록 설정할 수도 있습니다.
배출 확률 테이블을 중첩시키면, 예를 들어 1단계에서 SSR / SR / R 등의 레어도를 추첨하고, 2단계에서 해당 레어도에 대응하는 구체적인 콘텐츠를 추첨하는 등의 설정이 가능합니다.
이 구조를 통해 게임 전체의 레어도별 배출 확률을 관리하고 조정하기가 더 쉬워집니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeTableId | string | | ※ | | ~ 1024자 | 배출 확률 테이블 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 배출 확률 테이블 이름
배출 확률 테이블 고유의 이름입니다. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| metadata | string | | | | ~ 128자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| prizes | [List<Prize>](#prize) | | ✓ | | 1 ~ 100 items | 경품 리스트
이 배출 확률 테이블 내의 경품 리스트입니다. 각 경품은 배출 가중치(확률), 배출 시 실행할 액션, 그리고 선택적으로 배출 횟수 제한을 정의합니다. 각 경품의 실제 배출 확률은 해당 가중치를 테이블 내 전체 경품 가중치의 합으로 나누어 산출됩니다. |
**관련 메서드:**
describePrizeTables - 배출 확률 테이블 목록을 취득
getPrizeTable - 배출 확률 테이블을 취득
---
### Probability
배출 확률
특정 경품의 산출된 배출 확률을 나타냅니다. 확률은 배출 확률 테이블 내 전체 경품 가중치의 합에 대한 이 경품의 가중치로 계산됩니다. 박스 가챠의 경우, 경품이 박스에서 배출됨에 따라 확률이 동적으로 변화합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| prize | [DrawnPrize](#drawnprize) | | ✓ | | | 경품
이 확률이 대응하는 경품으로, ID와 입수 액션을 포함합니다. |
| rate | float | | ✓ | | 0 ~ 1.0 | 배출 확률 (0.0~1.0)
이 경품이 배출될 확률로, 0.0에서 1.0 사이의 값으로 표현됩니다. 이 경품의 가중치를 테이블 내 전체 경품 가중치의 합으로 나누어 산출됩니다. |
**관련 메서드:**
describeProbabilities - 배출 확률 목록 취득
describeProbabilitiesByUserId - 사용자 ID를 지정하여 배출 확률 목록 취득
---
### PrizeLimit
배출 횟수 제한
특정 경품이 전체 사용자를 통틀어 배출된 횟수를 추적합니다. 배출 횟수가 Prize의 drawnLimit에 정의된 최댓값에 도달하면, 대신 페일오버 경품이 배출됩니다. 희귀한 잭팟 아이템 등 수량 한정 경품을 구현하는 데 사용됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeLimitId | string | | ※ | | ~ 1024자 | 배출 횟수 제한 GRN
※ 서버가 자동으로 설정 |
| prizeId | string | | ✓ | | ~ 36자 | 경품 ID
배출 횟수가 추적되고 있는 경품의 ID입니다. |
| drawnCount | int | | ✓ | | 0 ~ 2147483646 | 배출 횟수
이 경품이 전체 사용자를 통틀어 배출된 현재 횟수입니다. 페일오버 경품을 사용해야 하는지를 판단하기 위해 Prize의 drawnLimit과 비교됩니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describePrizeLimits - 배출 횟수 제한 목록 취득
getPrizeLimit - 배출 횟수 제한 취득
---
### DrawnPrize
배출된 경품
추첨으로 배출된 경품을 나타냅니다. 경품 ID와 사용자에게 경품을 지급하기 위해 실행된 입수 액션을 포함합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeId | string | | ✓ | | ~ 36자 | 경품 ID
배출된 경품의 ID로, 배출 확률 테이블 내 경품 항목에 대응합니다. |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | | 0 ~ 100 items | 입수 액션 리스트
이 경품을 사용자에게 지급하기 위해 실행된 입수 액션의 리스트입니다. |
**관련 모델:**
Probability - 배출 확률
---
### BoxItems
박스 아이템 리스트
특정 사용자와 배출 확률 테이블에 대한 박스 가챠의 상태를 기록합니다. 박스 내 모든 경품과 그 잔여 수량·초기 수량의 리스트를 포함하여, 어떤 경품이 배출되었고 어떤 경품이 남아있는지 사용자가 확인할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| boxId | string | | ※ | | ~ 1024자 | 박스 GRN
※ 서버가 자동으로 설정 |
| prizeTableName | string | | ✓ | | ~ 128자 | 배출 확률 테이블 이름
이 박스와 연결된 배출 확률 테이블의 이름입니다. 이 레코드가 어느 박스 가챠에 속하는지를 식별합니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| items | [List<BoxItem>](#boxitem) | | | [] | 0 ~ 1000 items | 아이템 리스트
박스 내 모든 경품과 그 잔여 수량·초기 수량의 리스트입니다. 각 아이템은 해당 경품이 처음 박스에 몇 개 있었는지, 몇 개 남아있는지를 나타내며, 박스 가챠의 추첨 진행 상황을 추적할 수 있게 합니다. |
**관련 메서드:**
describeBoxes - 박스에서 꺼낸 아이템 리스트의 목록을 취득
describeBoxesByUserId - 사용자 ID를 지정하여 박스 목록을 취득
getBox - 박스 상태를 취득
getBoxByUserId - 사용자 ID를 지정하여 박스 상태를 취득
resetBox - 박스를 리셋
resetBoxByUserId - 사용자 ID를 지정하여 박스를 리셋
---
### LotteryModel
추첨 모델
추첨 모델은 배출 방식과 배출 테이블의 참조 방법을 정의하는 엔티티입니다.
배출 방식은 2종류가 마련되어 있으며, 일반 추첨은 매번 일정한 확률로 추첨하는 방식이고, 박스 추첨은 상자 안에 미리 정해진 수량의 경품이 들어 있어 추첨할 때마다 상자에서 경품을 꺼내는 추첨 방식입니다.
추첨 처리를 수행할 때 배출 확률 테이블을 사용하는데,
GS2-Script를 사용하면 여러 번 추첨을 실행할 때 배출 확률 테이블 일부만 다른 테이블로 교체할 수 있습니다.
이 구조를 이용하면 10연 가챠에서 1회만 다른 추첨 확률 테이블을 적용하는 것이 가능해집니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| lotteryModelId | string | | ※ | | ~ 1024자 | 추첨 모델 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 추첨 모델 이름
추첨 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에 영향을 미치지 않으므로, 게임 내에서 사용할 정보를 저장하는 용도로 사용할 수 있습니다. |
| mode | 문자열 열거형
enum {
"normal",
"box"
}
| | ✓ | | | 추첨 모드
경품의 추첨 방식을 선택합니다. "normal"은 매번 일정한 확률로 추첨을 진행합니다(경품은 반복해서 배출됩니다). "box"는 가상의 상자에 미리 정해진 수량의 경품을 넣어두고, 추첨할 때마다 상자에서 경품을 꺼냅니다(모든 경품이 최종적으로 배출되는 것이 보장됩니다).normal: 일반 추첨 / box: 박스 추첨 / |
| method | 문자열 열거형
enum {
"prize_table",
"script"
}
| | ✓ | | | 추첨 방법
배출 확률 테이블의 참조 방법을 결정합니다. "prize_table"은 정적으로 지정된 배출 확률 테이블을 사용합니다. "script"는 GS2-Script를 사용하여 추첨 시점에 배출 확률 테이블을 동적으로 선택하며, 10연 가챠에서 1회만 다른 배출 확률 테이블을 적용하는 등의 시나리오를 실현할 수 있습니다.prize_table: 정적 배출 확률 테이블 / script: GS2-Script를 사용한 동적 배출 확률 테이블 / |
| prizeTableName | string | {method} == "prize_table" | ✓※ | | ~ 128자 | 배출 확률 테이블 이름
이 추첨 모델에서 사용할 배출 확률 테이블의 이름입니다. 추첨 방법이 "prize_table"인 경우 필수입니다.
※ method이(가) "prize_table" 이면 필수 |
| choicePrizeTableScriptId | string | {method} == "script" | ✓※ | | ~ 1024자 | 배출 확률 테이블을 결정하는 GS2-Script의 스크립트 GRN
Script 트리거 레퍼런스 - [`choicePrizeTable`](../script/#choiceprizetable)
※ method이(가) "script" 이면 필수 |
**관련 메서드:**
describeLotteryModels - 추첨 모델 목록 취득
getLotteryModel - 추첨 모델 취득
---
### Prize
경품
배출 확률 테이블 내 단일 경품 엔트리입니다.
경품은 입수 액션(아이템이나 통화의 부여 등)을 직접 지정하거나, 다른 배출 확률 테이블을 참조하여 중첩된 추첨을 수행할 수 있습니다.
각 경품에는 배출 가중치가 있으며, 배출되는 상대적 확률을 결정합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeId | string | | ✓ | UUID | ~ 36자 | 경품 ID
배출 확률 테이블 내에서 이 경품을 고유하게 식별하는 ID입니다. 배출 횟수 제한 추적 및 페일오버 경품 지정 시 참조에 사용됩니다. |
| type | 문자열 열거형
enum {
"action",
"prize_table"
}
| | ✓ | | | 경품 종류
이 경품이 직접 보상을 부여하는지, 다른 배출 확률 테이블에 위임하는지를 결정합니다. "action"은 배출 시 실행할 입수 액션을 지정합니다. "prize_table"은 다른 배출 확률 테이블을 참조하여 중첩된 추첨을 수행합니다(예: 1단계에서 희귀도를 결정하고, 2단계에서 구체적인 아이템을 결정).action: 경품의 입수 액션 / prize_table: 더욱 배출 확률 테이블을 지정하여 재추첨 / |
| acquireActions | [List<AcquireAction>](#acquireaction) | {type} == "action" | | [] | 1 ~ 100 items | 입수 액션 리스트
이 경품이 배출될 때 실행할 입수 액션의 리스트입니다. 여러 액션을 지정하여 한 번에 여러 보상을 부여할 수 있습니다(예: 아이템과 통화를 동시에 부여).
※ type이(가) "action" 이면 활성화 |
| drawnLimit | int | {type} == "action" | | | 1 ~ 1000000 | 최대 배출 수
이 경품이 전체 사용자를 통틀어 배출될 수 있는 최대 횟수입니다. 제한에 도달하면 대신 페일오버 경품(limitFailOverPrizeId)이 배출됩니다. 잭팟 아이템 등 수량 한정 경품 구현에 사용됩니다.
※ type이(가) "action" 이면 활성화 |
| limitFailOverPrizeId | string | {type} == "action" and {drawnLimit} > 0 | ✓※ | | ~ 32자 | 제한 시 페일오버 경품 ID
이 경품의 배출 횟수 제한(drawnLimit)에 도달했을 때 대신 배출할 경품의 ID입니다. 동일한 배출 확률 테이블 내의 다른 경품을 참조해야 합니다.
※ type이(가) "action"이고 drawnLimit이(가) 0 보다 크면 필수 |
| prizeTableName | string | {type} == "prize_table" | ✓※ | | ~ 128자 | 배출 확률 테이블의 이름
추첨을 위임할 배출 확률 테이블의 이름입니다. 경품 타입이 "prize_table"인 경우 중첩된 추첨에 사용됩니다.
※ type이(가) "prize_table" 이면 필수 |
| weight | int | | ✓ | | 1 ~ 2147483646 | 배출 가중치
배출 확률 테이블 내에서 이 경품의 상대적 가중치입니다. 실제 배출 확률은 이 경품의 가중치를 테이블 내 모든 경품의 가중치 합계로 나누어 산출됩니다. 예를 들어 3개의 경품의 가중치가 각각 70, 20, 10이라면 각각의 배출 확률은 70%, 20%, 10%가 됩니다. |
**관련 모델:**
PrizeTable - 배출 확률 테이블
PrizeTableMaster - 배출 확률 테이블 마스터
---
### BoxItem
박스 아이템
박스 가챠 내 단일 경품 유형을 나타내며, 박스 내 초기 수량, 잔여 수량, 그리고 배출 시 실행되는 입수 액션을 나타냅니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeId | string | | ✓ | | ~ 128자 | 경품 ID
이 박스 아이템이 대응하는 배출 확률 테이블 내 경품 ID입니다. |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | [] | 0 ~ 100 items | 입수 액션 리스트
이 경품이 박스에서 배출되었을 때 실행할 입수 액션의 리스트입니다. |
| remaining | int | | ✓ | | 0 ~ 2147483646 | 잔여 수량
박스 내에 남아있는 이 경품의 수입니다. 이 경품이 배출될 때마다 1개씩 감소합니다. |
| initial | int | | ✓ | | 0 ~ 2147483646 | 초기 수량
처음 박스에 담긴 이 경품의 수입니다. 잔여 수량과 함께 얼마나 배출되었는지를 계산하는 데 사용됩니다. |
**관련 모델:**
BoxItems - 박스 아이템 리스트
---
### AcquireAction
입수 액션
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 문자열 열거형
enum {
}
| | ✓ | | | 입수 액션에서 실행할 액션의 종류 |
| request | string | | ✓ | | ~ 524288자 | 액션 실행 시 사용되는 요청의 JSON 문자열 |
**관련 모델:**
DrawnPrize - 배출된 경품
Prize - 경품
BoxItem - 박스 아이템
---
### Config
컨피그 설정
트랜잭션의 변수에 적용하는 설정 값
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| key | string | | ✓ | | ~ 64자 | 이름 |
| value | string | | | | ~ 51200자 | 값 |
---
### VerifyActionResult
검증 액션 실행 결과
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 문자열 열거형
enum {
}
| | ✓ | | | 검증 액션에서 실행할 액션의 종류 |
| verifyRequest | string | | ✓ | | ~ 524288자 | 액션 실행 시 사용되는 요청의 JSON 문자열 |
| statusCode | int | | | | 0 ~ 999 | 상태 코드 |
| verifyResult | string | | | | ~ 1048576자 | 결과 내용 |
**관련 모델:**
TransactionResult - 트랜잭션 실행 결과
---
### ConsumeActionResult
소비 액션 실행 결과
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 문자열 열거형
enum {
}
| | ✓ | | | 소비 액션에서 실행할 액션의 종류 |
| consumeRequest | string | | ✓ | | ~ 524288자 | 액션 실행 시 사용되는 요청의 JSON 문자열 |
| statusCode | int | | | | 0 ~ 999 | 상태 코드 |
| consumeResult | string | | | | ~ 1048576자 | 결과 내용 |
**관련 모델:**
TransactionResult - 트랜잭션 실행 결과
---
### AcquireActionResult
획득 액션 실행 결과
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 문자열 열거형
enum {
}
| | ✓ | | | 입수 액션에서 실행할 액션의 종류 |
| acquireRequest | string | | ✓ | | ~ 524288자 | 액션 실행 시 사용되는 요청의 JSON 문자열 |
| statusCode | int | | | | 0 ~ 999 | 상태 코드 |
| acquireResult | string | | | | ~ 1048576자 | 결과 내용 |
**관련 모델:**
TransactionResult - 트랜잭션 실행 결과
---
### TransactionResult
트랜잭션 실행 결과
서버 사이드에서 트랜잭션 자동 실행 기능을 이용하여 실행된 트랜잭션의 실행 결과
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| transactionId | string | | ✓ | | 36 ~ 36자 | 트랜잭션 ID |
| verifyResults | [List<VerifyActionResult>](#verifyactionresult) | | | | 0 ~ 10 items | 검증 액션의 실행 결과 목록 |
| consumeResults | [List<ConsumeActionResult>](#consumeactionresult) | | | [] | 0 ~ 10 items | 소비 액션의 실행 결과 목록 |
| acquireResults | [List<AcquireActionResult>](#acquireactionresult) | | | [] | 0 ~ 100 items | 획득 액션 실행 결과 리스트 |
| hasError | bool | | | false | | 트랜잭션 실행 중 오류가 발생했는지 여부 |
---
### CurrentLotteryMaster
현재 활성화된 추첨 모델의 마스터 데이터
현재 네임스페이스 내에서 유효한 추첨 모델의 정의를 기술한 마스터 데이터입니다.
GS2에서는 마스터 데이터 관리에 JSON 형식의 파일을 사용합니다.
파일을 업로드하면 실제로 서버에 설정을 반영할 수 있습니다.
JSON 파일을 작성하는 방법으로, 매니지먼트 콘솔 내에 마스터 데이터 에디터를 제공하고 있습니다.
또한 게임 운영에 더 적합한 도구를 직접 제작하여 적절한 포맷의 JSON 파일을 출력하는 방식으로도 서비스를 이용할 수 있습니다.
**ℹ️ Note**
JSON 파일 형식에 대해서는 [GS2-Lottery 마스터 데이터 레퍼런스](api_reference/lottery/master_data/)를 참조해 주세요.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024자 | 네임스페이스 GRN
※ 서버가 자동으로 설정 |
| settings | string | | ✓ | | ~ 5242880 바이트 (5MB) | 마스터 데이터 |
**관련 메서드:**
exportMaster - 추첨 모델 마스터를 활성화 가능한 마스터 데이터 형식으로 내보내기
getCurrentLotteryMaster - 현재 활성화된 추첨 모델의 마스터 데이터를 취득
updateCurrentLotteryMaster - 현재 활성화된 추첨 모델 마스터 데이터를 업데이트
updateCurrentLotteryMasterFromGitHub - 현재 활성화된 추첨 모델 마스터 데이터를 GitHub에서 업데이트
---
### LotteryModelMaster
추첨 모델 마스터
추첨 모델 마스터는 게임 내에서 사용되는 추첨 모델의 편집·관리용 데이터로, 매니지먼트 콘솔의 마스터 데이터 에디터에 임시로 저장됩니다.
임포트·갱신 처리를 수행함으로써 실제로 게임에서 참조되는 추첨 모델로 반영됩니다.
추첨 모델은 배출 방식과 배출 테이블 참조 방법을 정의하는 엔티티입니다.
배출 방식은 2종류가 준비되어 있으며, 일반 추첨은 매번 일정한 확률로 추첨하는 방식이고, Box 추첨은 상자 안에 미리 정의된 수량의 경품이 들어 있어 추첨할 때마다 상자에서 경품을 꺼내는 추첨 방식입니다.
추첨 처리를 수행할 때 배출 확률 테이블을 이용하는데,
GS2-Script를 사용하면 여러 번 추첨을 실행할 때 배출 확률 테이블을 일부만 다른 테이블로 교체할 수 있습니다.
이 구조를 이용하면 10연 가챠에서 1회만 다른 추첨 확률 테이블을 적용하는 것이 가능해집니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| lotteryModelId | string | | ※ | | ~ 1024자 | 추첨 모델 마스터 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 추첨 모델 이름
추첨 모델 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| mode | 문자열 열거형
enum {
"normal",
"box"
}
| | ✓ | | | 추첨 모드
경품의 추첨 방식을 선택합니다. "normal"은 매번 일정한 확률로 추첨을 진행합니다(경품은 반복해서 배출됩니다). "box"는 가상의 상자에 미리 정해진 수량의 경품을 넣어두고, 추첨할 때마다 상자에서 경품을 꺼냅니다(모든 경품이 최종적으로 배출되는 것이 보장됩니다).normal: 일반 추첨 / box: 박스 추첨 / |
| method | 문자열 열거형
enum {
"prize_table",
"script"
}
| | ✓ | | | 추첨 방법
배출 확률 테이블의 참조 방법을 결정합니다. "prize_table"은 정적으로 지정된 배출 확률 테이블을 사용합니다.
"script"는 GS2-Script를 사용하여 추첨 시점에 배출 확률 테이블을 동적으로 선택하며, 10연 가챠에서 1회만 다른 배출 확률 테이블을 적용하는 등의 시나리오를 구현할 수 있습니다.prize_table: 정적 배출 확률 테이블 / script: GS2-Script를 사용한 동적 배출 확률 테이블 / |
| prizeTableName | string | {method} == "prize_table" | ✓※ | | ~ 128자 | 배출 확률 테이블 이름
이 추첨 모델에서 사용할 배출 확률 테이블의 이름입니다. 추첨 방법이 "prize_table"인 경우 필수입니다.
※ method이(가) "prize_table" 이면 필수 |
| choicePrizeTableScriptId | string | {method} == "script" | ✓※ | | ~ 1024자 | 배출 확률 테이블을 결정하는 GS2-Script의 스크립트 GRN
Script 트리거 레퍼런스 - [`choicePrizeTable`](../script/#choiceprizetable)
※ method이(가) "script" 이면 필수 |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeLotteryModelMasters - 추첨 모델 마스터 목록 취득
createLotteryModelMaster - 추첨 모델 마스터 신규 작성
getLotteryModelMaster - 추첨 모델 마스터 취득
updateLotteryModelMaster - 추첨 모델 마스터 갱신
deleteLotteryModelMaster - 추첨 모델 마스터 삭제
---
### PrizeTableMaster
배출 확률 테이블 마스터
배출 확률 테이블 마스터는 게임 내에서 사용되는 배출 확률 테이블의 편집·관리용 데이터로, 매니지먼트 콘솔의 마스터 데이터 에디터에서 일시적으로 보관됩니다.
임포트·업데이트 처리를 수행하면 실제로 게임에서 참조하는 배출 확률 테이블로 반영됩니다.
경품에는 입수 액션을 직접 지정하거나, 다른 배출 확률 테이블을 참조하도록 설정할 수도 있습니다.
배출 확률 테이블을 중첩시키면, 예를 들어 1단계에서 SSR / SR / R 등의 레어도를 추첨하고, 2단계에서 해당 레어도에 대응하는 구체적인 콘텐츠를 추첨하는 등의 설정이 가능합니다.
이 구조를 통해 게임 전체의 레어도별 배출 확률을 관리하고 조정하기가 더 쉬워집니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| prizeTableId | string | | ※ | | ~ 1024자 | 배출 확률 테이블 마스터 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 배출 확률 테이블 이름
배출 확률 테이블 고유의 이름입니다. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| metadata | string | | | | ~ 128자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| prizes | [List<Prize>](#prize) | | ✓ | | 1 ~ 100 items | 경품 리스트
이 배출 확률 테이블 내의 경품 리스트입니다. 각 경품은 배출 가중치(확률), 배출 시 실행할 액션, 그리고 선택적으로 배출 횟수 제한을 정의합니다. 각 경품의 실제 배출 확률은 해당 가중치를 테이블 내 전체 경품 가중치의 합으로 나누어 산출됩니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describePrizeTableMasters - 배출 확률 테이블 마스터 목록을 취득
createPrizeTableMaster - 배출 확률 테이블 마스터를 신규 생성
getPrizeTableMaster - 배출 확률 테이블 마스터를 취득
updatePrizeTableMaster - 배출 확률 테이블 마스터를 업데이트
deletePrizeTableMaster - 배출 확률 테이블 마스터를 삭제
---
## 메서드
### describeNamespaces
네임스페이스 목록 조회
프로젝트 내에서 서비스 단위로 생성된 네임스페이스의 목록을 조회합니다.
옵션인 페이지 토큰을 사용하여 목록의 특정 위치부터 데이터 조회를 시작할 수 있습니다.
또한 조회할 네임스페이스의 수를 제한하는 것도 가능합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namePrefix | string | | | | ~ 64자 | 네임스페이스 이름의 필터 접두사 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Namespace>](#namespace) | 네임스페이스 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**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
네임스페이스 신규 생성
네임스페이스의 이름, 설명 및 각종 설정을 포함한 상세 정보를 지정해야 합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | ✓| | | 트랜잭션 설정
추첨 조작 시 트랜잭션의 처리 방법을 제어하는 설정입니다. 추첨에서는 입수 액션을 통해 사용자에게 경품을 지급하는 트랜잭션이 발행됩니다. |
| lotteryTriggerScriptId | string | | | | ~ 1024자 | 추첨을 실행했을 때 호출되는 GS2-Script의 스크립트 GRN
Script 트리거 레퍼런스 - [`lottery`](../script/#lottery) |
| logSetting | [LogSetting](#logsetting) | | | | | 로그 출력 설정
추첨 조작의 API 요청·응답 로그를 출력하기 위한 GS2-Log 네임스페이스를 지정합니다. 디버그 및 분석을 위해 추첨 결과, 경품 배포, 박스 가챠 상태 추적에 유용합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 생성한 네임스페이스 |
#### 구현 예제
**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
네임스페이스의 상태 조회
지정된 네임스페이스의 현재 상태를 조회합니다.
상태에는 네임스페이스가 활성 상태인지, 삭제되었는지가 포함됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| status | string | 네임스페이스의 상태
ACTIVE: 유효 / DELETED: 삭제됨 / |
#### 구현 예제
**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
네임스페이스 조회
지정된 네임스페이스의 상세 정보를 조회합니다.
여기에는 네임스페이스의 이름, 설명 및 기타 설정 정보가 포함됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 네임스페이스 |
#### 구현 예제
**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
네임스페이스 갱신
지정된 네임스페이스의 설정을 갱신합니다.
네임스페이스의 설명이나 특정 설정을 변경할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | ✓| | | 트랜잭션 설정
추첨 조작 시 트랜잭션의 처리 방법을 제어하는 설정입니다. 추첨에서는 입수 액션을 통해 사용자에게 경품을 지급하는 트랜잭션이 발행됩니다. |
| lotteryTriggerScriptId | string | | | | ~ 1024자 | 추첨을 실행했을 때 호출되는 GS2-Script의 스크립트 GRN
Script 트리거 레퍼런스 - [`lottery`](../script/#lottery) |
| logSetting | [LogSetting](#logsetting) | | | | | 로그 출력 설정
추첨 조작의 API 요청·응답 로그를 출력하기 위한 GS2-Log 네임스페이스를 지정합니다. 디버그 및 분석을 위해 추첨 결과, 경품 배포, 박스 가챠 상태 추적에 유용합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 갱신한 네임스페이스 |
#### 구현 예제
**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
네임스페이스 삭제
지정된 네임스페이스를 삭제합니다.
이 작업은 되돌릴 수 없으며, 삭제된 네임스페이스와 관련된 모든 데이터는 복구할 수 없게 됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 삭제한 네임스페이스 |
#### 구현 예제
**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
마이크로서비스 버전 조회
#### Request
요청 파라미터: 없음
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | string | 버전 |
#### 구현 예제
**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
지정한 사용자 ID에 연결된 데이터의 덤프 취득
개인정보 보호에 관한 법적 요건을 충족시키기 위해 사용하거나, 데이터의 백업 및 이관에 사용할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
반환값: 없음
#### 구현 예제
**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
지정한 사용자 ID에 연결된 데이터의 덤프가 완료되었는지 확인
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| url | string | 출력 데이터의 URL |
#### 구현 예제
**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
사용자 데이터 완전 삭제
지정된 사용자 ID에 연결된 데이터의 클리닝을 실행합니다.
이를 통해 특정 사용자 데이터를 프로젝트에서 안전하게 삭제할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
반환값: 없음
#### 구현 예제
**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
지정한 사용자 ID의 사용자 데이터 완전 삭제가 완료되었는지 확인
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
반환값: 없음
#### 구현 예제
**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
지정한 사용자 ID에 연결된 데이터의 임포트 준비
임포트에 사용할 수 있는 데이터는 GS2 를 통해 익스포트하여 취득한 데이터로 한정되며, 오래된 데이터는 임포트에 실패할 수 있습니다.
익스포트한 사용자 ID와 다른 사용자 ID로 임포트할 수 있지만, 사용자 데이터의 페이로드 내에 사용자 ID가 포함되어 있는 경우에는 그렇지 않을 수 있습니다.
이 API의 반환값으로 응답된 URL에 익스포트한 zip 파일을 업로드하고 importUserDataByUserId 를 호출함으로써 실제 임포트 처리를 시작할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| uploadToken | string | 업로드 후 결과를 반영할 때 사용하는 토큰 |
| uploadUrl | string | 사용자 데이터 업로드 처리 실행에 사용하는 URL |
#### 구현 예제
**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
지정한 사용자 ID에 연결된 데이터의 임포트 실행
임포트에 사용할 수 있는 데이터는 GS2 를 통해 익스포트하여 취득한 데이터로 한정되며, 오래된 데이터는 임포트에 실패할 수 있습니다.
익스포트한 사용자 ID와 다른 사용자 ID로 임포트할 수 있지만, 사용자 데이터의 페이로드 내에 사용자 ID가 포함되어 있는 경우에는 그렇지 않을 수 있습니다.
이 API를 호출하기 전에 prepareImportUserDataByUserId 를 호출하여 업로드 준비를 완료해야 합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| uploadToken | string | | ✓| | ~ 1024자 | 업로드 준비 시 수신한 토큰 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
반환값: 없음
#### 구현 예제
**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
지정한 사용자 ID에 연결된 데이터의 임포트가 완료되었는지 확인
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| uploadToken | string | | ✓| | ~ 1024자 | 업로드 준비 시 수신한 토큰 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| url | string | 출력 로그의 URL |
#### 구현 예제
**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
배출 확률 테이블 목록을 취득
지정한 네임스페이스의 현재 활성화된 배출 확률 테이블 목록을 취득합니다.
배출 확률 테이블은 추첨 모델이 사용하는 경품과 그 배출 확률 또는 가중치를 정의합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<PrizeTable>](#prizetable) | 배출 확률 테이블 목록 |
#### 구현 예제
**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
배출 확률 테이블을 취득
지정한 배출 확률 테이블의 경품 리스트, 배출 확률, 가중치, 수량 제한을 포함한 정보를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름
배출 확률 테이블 고유의 이름입니다. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [PrizeTable](#prizetable) | 배출 확률 테이블 |
#### 구현 예제
**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
사용자 ID를 지정하여 추첨을 실행
추첨 모델의 설정에 따라 지정한 사용자의 추첨을 실행합니다.
추첨은 두 가지 방식을 지원합니다: 배출 확률 테이블 모드(사전에 정의된 확률 테이블 사용)와 스크립트 모드(GS2-Script로 경품을 결정).
박스 추첨 모드에서는 배출된 경품이 박스에서 삭제되어 다시 배출되지 않습니다. 박스가 비어 있는 경우 Empty 오류가 반환됩니다.
배출된 경품은 트랜잭션으로 발행됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름 |
| lotteryName | string | | ✓| | ~ 128자 | 추첨 모델 이름
추첨 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| count | int | | ✓| | 1 ~ 1000 | 추첨 횟수 |
| config | [List<Config>](#config) | | | [] | 0 ~ 1000 items | 트랜잭션의 플레이스홀더에 적용하는 설정값 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | 추첨 결과 경품 리스트 |
| boxItems | [BoxItems](#boxitems) | 박스에서 꺼낸 아이템 리스트 |
| transactionId | string | 발행된 트랜잭션 ID |
| stampSheet | string | 배출된 경품을 획득하기 위한 스탬프 시트 |
| stampSheetEncryptionKeyId | string | 스탬프 시트의 서명 계산에 사용한 암호화 키 GRN |
| autoRunStampSheet | bool? | 트랜잭션 자동 실행이 활성화되어 있는지 여부 |
| atomicCommit | bool? | 트랜잭션을 원자적으로 커밋할지 여부 |
| transaction | string | 발행된 트랜잭션 |
| transactionResult | [TransactionResult](#transactionresult) | 트랜잭션 실행 결과 |
#### 구현 예제
**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
추첨 결과의 예측 결과를 취득
실제로 경품을 지급하거나 트랜잭션을 생성하지 않고 추첨 결과를 예측합니다.
난수 시드를 사용하여 결정론적 결과를 반환하므로, 동일한 시드로 동일한 예측 결과를 재현할 수 있습니다.
추첨을 실행하기 전에 플레이어에게 받을 경품을 표시할 때 유용합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름 |
| lotteryName | string | | ✓| | ~ 128자 | 추첨 모델 이름 |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| randomSeed | long | | ✓| | 0 ~ 9223372036854775805 | 난수 시드 |
| count | int | | ✓| | 1 ~ 1000 | 추첨 횟수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | 추첨 결과 경품 리스트 |
#### 구현 예제
**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
사용자 ID를 지정하여 추첨 결과의 예측 결과를 취득
지정한 사용자의 추첨 결과를, 경품 지급이나 트랜잭션 생성 없이 예측합니다.
난수 시드를 사용하여 결정론적 결과를 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름 |
| lotteryName | string | | ✓| | ~ 128자 | 추첨 모델 이름 |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| randomSeed | long | | ✓| | 0 ~ 9223372036854775805 | 난수 시드 |
| count | int | | ✓| | 1 ~ 1000 | 추첨 횟수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | 추첨 결과 경품 리스트 |
#### 구현 예제
**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
사용자 ID를 지정하여 난수 시드를 사용한 추첨을 실행
지정한 난수 시드를 사용하여 결정론적 추첨을 실행합니다.
난수 시드는 각 추첨의 반복 횟수만큼 오프셋되어, 고유하면서도 재현 가능한 결과를 보장합니다.
이 방식은 박스 추첨 모드와 호환되지 않습니다. 배출된 경품은 트랜잭션으로 발행됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름 |
| lotteryName | string | | ✓| | ~ 128자 | 추첨 모델 이름 |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| randomSeed | long | | ✓| | 0 ~ 9223372036854775805 | 난수 시드 |
| count | int | | ✓| | 1 ~ 1000 | 추첨 횟수 |
| config | [List<Config>](#config) | | | [] | 0 ~ 1000 items | 트랜잭션의 플레이스홀더에 적용하는 설정값 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<DrawnPrize>](#drawnprize) | 추첨 결과 경품 리스트 |
| transactionId | string | 발행된 트랜잭션 ID |
| stampSheet | string | 배출된 경품을 획득하기 위한 스탬프 시트 |
| stampSheetEncryptionKeyId | string | 스탬프 시트의 서명 계산에 사용한 암호화 키 GRN |
| autoRunStampSheet | bool? | 트랜잭션 자동 실행이 활성화되어 있는지 여부 |
| atomicCommit | bool? | 트랜잭션을 원자적으로 커밋할지 여부 |
| transaction | string | 발행된 트랜잭션 |
| transactionResult | [TransactionResult](#transactionresult) | 트랜잭션 실행 결과 |
#### 구현 예제
**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
배출 확률 목록 취득
일반 추첨에서는 모든 게임 플레이어에게 동일한 확률로 응답합니다.
박스 추첨에서는 박스 내용물의 잔여 상태를 고려하여 게임 플레이어마다 다른 확률로 응답합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| lotteryName | string | | ✓| | ~ 128자 | 추첨 모델 이름
추첨 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Probability>](#probability) | 배출 확률 목록 |
#### 구현 예제
**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
사용자 ID를 지정하여 배출 확률 목록 취득
일반 추첨에서는 모든 게임 플레이어에게 동일한 확률로 응답합니다.
박스 추첨에서는 박스 내용물의 잔여 상태를 고려하여 게임 플레이어마다 다른 확률로 응답합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| lotteryName | string | | ✓| | ~ 128자 | 추첨 모델 이름
추첨 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Probability>](#probability) | 배출 확률 목록 |
#### 구현 예제
**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
배출 횟수 제한 목록 취득
지정된 배출 확률 테이블의 경품 배출 횟수 제한에 대한 페이지네이션 목록을 취득합니다.
배출 횟수 제한은 각 경품의 배출 횟수를 추적하여, 수량 한정 경품 설정을 가능하게 합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름
배출 확률 테이블 고유의 이름입니다. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<PrizeLimit>](#prizelimit) | 배출 횟수 제한 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**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
배출 횟수 제한 취득
배출 확률 테이블 내 특정 경품의 현재 배출 횟수 제한을 취득합니다.
설정된 제한에 대해 경품이 몇 번 배출되었는지 확인할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름
배출 확률 테이블 고유의 이름입니다. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| prizeId | string | | ✓| UUID | ~ 36자 | 경품 ID
배출 확률 테이블 내에서 이 경품을 고유하게 식별하는 ID입니다. 배출 횟수 제한 추적 및 페일오버 경품 지정 시 참조에 사용됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [PrizeLimit](#prizelimit) | 배출 횟수 제한 |
#### 구현 예제
**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
배출 횟수 리셋
배출 횟수 레코드를 삭제하여 특정 경품의 배출 횟수를 리셋합니다.
리셋 후 경품은 설정된 제한까지 다시 배출 가능해집니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름
배출 확률 테이블 고유의 이름입니다. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| prizeId | string | | ✓| UUID | ~ 36자 | 경품 ID
배출 확률 테이블 내에서 이 경품을 고유하게 식별하는 ID입니다. 배출 횟수 제한 추적 및 페일오버 경품 지정 시 참조에 사용됩니다. |
#### Result
반환값: 없음
#### 구현 예제
**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
박스에서 꺼낸 아이템 리스트의 목록을 취득
네임스페이스 내 모든 박스 모드 추첨 모델의 박스 상태를 페이지네이션으로 취득합니다.
각 항목은 박스에서 어떤 경품이 배출되었는지와 남은 수량을 나타냅니다.
아직 추첨이 이루어지지 않은 박스의 경우, 빈 박스 상태가 생성되어 반환됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<BoxItems>](#boxitems) | 박스 상태 리스트 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**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
사용자 ID를 지정하여 박스 목록을 취득
지정한 사용자의 모든 박스 모드 추첨 모델의 박스 상태를 페이지네이션으로 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<BoxItems>](#boxitems) | 박스 상태 리스트 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**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
박스 상태를 취득
특정 배출 확률 테이블의 박스 상태를 취득하여 어떤 경품이 배출되었는지와 남은 수량을 표시합니다.
박스가 아직 존재하지 않는 경우, 빈 박스 상태가 생성되어 반환됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름 |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | 박스 내 경품과 잔여 수량 정보 |
#### 구현 예제
**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
사용자 ID를 지정하여 박스 상태를 취득
지정한 사용자의 특정 배출 확률 테이블의 박스 상태를 취득하여 배출된 경품과 남은 수량을 표시합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름 |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | 박스 내 경품과 잔여 수량 정보 |
#### 구현 예제
**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
박스를 리셋
박스를 초기 상태로 리셋하고, 배출된 모든 경품을 박스로 되돌립니다.
리셋 후에는 모든 경품을 다시 배출받을 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름 |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | 박스 내 경품과 초기 수량 정보 |
#### 구현 예제
**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
사용자 ID를 지정하여 박스를 리셋
지정한 사용자의 박스를 초기 상태로 리셋하고, 배출된 모든 경품을 박스로 되돌립니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름 |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [BoxItems](#boxitems) | 박스 내 경품과 초기 수량 정보 |
#### 구현 예제
**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
추첨 모델 목록 취득
지정된 네임스페이스의 현재 활성화된 추첨 모델 목록을 취득합니다.
모델은 추첨 모드(일반 또는 박스), 추첨 방식(배출 확률 테이블 또는 스크립트), 관련된 배출 확률 테이블의 설정을 정의합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<LotteryModel>](#lotterymodel) | 추첨 모델 목록 |
#### 구현 예제
**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
추첨 모델 취득
지정된 추첨 모델의 모드(일반/박스), 추첨 방식(배출 확률 테이블/스크립트), 배출 확률 테이블 이름을 포함한 정보를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| lotteryName | string | | ✓| | ~ 128자 | 추첨 모델 이름
추첨 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [LotteryModel](#lotterymodel) | 추첨 모델 |
#### 구현 예제
**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
추첨 모델 마스터를 활성화 가능한 마스터 데이터 형식으로 내보내기
현재 활성화된 추첨 모델 마스터를 활성화 가능한 형식으로 내보냅니다.
내보낸 데이터는 다른 네임스페이스의 마스터 데이터 업데이트나 백업으로 사용할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentLotteryMaster](#currentlotterymaster) | 활성화 가능한 추첨 모델의 마스터 데이터 |
#### 구현 예제
**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
현재 활성화된 추첨 모델의 마스터 데이터를 취득
지정한 네임스페이스의 현재 활성화된 추첨 모델의 마스터 데이터를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentLotteryMaster](#currentlotterymaster) | 현재 활성화된 추첨 모델의 마스터 데이터 |
#### 구현 예제
**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
현재 활성화된 추첨 모델 마스터 데이터를 업데이트(3단계 버전)
1MB를 초과하는 마스터 데이터를 업로드하는 경우, 3단계로 나누어 업데이트를 진행합니다.
1. 이 API를 실행하여 업로드용 토큰과 URL을 취득합니다.
2. 취득한 URL에 마스터 데이터를 업로드합니다.
3. UpdateCurrentLotteryMaster에 업로드로 취득한 토큰을 전달하여 실행하고, 마스터 데이터를 반영합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| uploadToken | string | 업로드 후 결과를 반영할 때 사용하는 토큰 |
| uploadUrl | string | 업로드 처리 실행에 사용하는 URL |
#### 구현 예제
**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
현재 활성화된 추첨 모델 마스터 데이터를 업데이트
현재 활성화된 추첨 모델의 마스터 데이터를 업데이트합니다.
두 가지 모드를 지원합니다: 인라인 설정용 'direct' 모드와, 3단계 업데이트 과정에서 사전에 업로드한 설정을 적용하는 'preUpload' 모드입니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| mode | 문자열 열거형
enum {
"direct",
"preUpload"
}
| | | "direct" | | 업데이트 모드direct: 마스터 데이터를 직접 업데이트 / preUpload: 마스터 데이터를 업로드한 후 업데이트 / |
| settings | string | {mode} == "direct" | ✓※| | ~ 5242880 바이트 (5MB) | 마스터 데이터
※ mode이(가) "direct" 이면 필수 |
| uploadToken | string | {mode} == "preUpload" | ✓※| | ~ 1024자 | 사전 업로드로 획득한 토큰
업로드한 마스터 데이터를 적용하기 위해 사용됩니다.
※ mode이(가) "preUpload" 이면 필수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentLotteryMaster](#currentlotterymaster) | 업데이트된 현재 활성화된 추첨 모델의 마스터 데이터 |
#### 구현 예제
**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
현재 활성화된 추첨 모델 마스터 데이터를 GitHub에서 업데이트
지정한 GitHub 리포지토리에서 마스터 데이터를 가져와 현재 활성화된 추첨 모델의 마스터 데이터를 업데이트합니다.
GS2-Key에 저장된 API 키가 인증에 사용되며, 체크아웃할 브랜치, 태그, 또는 커밋 해시를 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| checkoutSetting | [GitHubCheckoutSetting](#githubcheckoutsetting) | | ✓| | | GitHub에서 마스터 데이터를 체크아웃하는 설정 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentLotteryMaster](#currentlotterymaster) | 업데이트된 현재 활성화된 추첨 모델의 마스터 데이터 |
#### 구현 예제
**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
추첨 모델 마스터 목록 취득
지정된 네임스페이스의 추첨 모델 마스터에 대한 페이지네이션 목록을 취득합니다.
이름의 접두사로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| namePrefix | string | | | | ~ 64자 | 추첨 모델 이름의 필터 접두사 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<LotteryModelMaster>](#lotterymodelmaster) | 추첨 모델 마스터 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**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
추첨 모델 마스터 신규 작성
지정된 설정으로 새로운 추첨 모델 마스터를 작성합니다.
모드는 'normal'(복원 추첨: 배출된 경품도 다시 배출됨) 또는 'box'(비복원 추첨: 배출된 경품은 풀에서 제외됨)를 지정할 수 있습니다.
방식은 'prizeTable'(사전 정의된 배출 확률 테이블 사용) 또는 'script'(GS2-Script로 동적으로 경품을 결정)를 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| name | string | | ✓| | ~ 128자 | 추첨 모델 이름
추첨 모델 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| mode | 문자열 열거형
enum {
"normal",
"box"
}
| | ✓| | | 추첨 모드
경품의 추첨 방식을 선택합니다. "normal"은 매번 일정한 확률로 추첨을 진행합니다(경품은 반복해서 배출됩니다). "box"는 가상의 상자에 미리 정해진 수량의 경품을 넣어두고, 추첨할 때마다 상자에서 경품을 꺼냅니다(모든 경품이 최종적으로 배출되는 것이 보장됩니다).normal: 일반 추첨 / box: 박스 추첨 / |
| method | 문자열 열거형
enum {
"prize_table",
"script"
}
| | ✓| | | 추첨 방법
배출 확률 테이블의 참조 방법을 결정합니다. "prize_table"은 정적으로 지정된 배출 확률 테이블을 사용합니다.
"script"는 GS2-Script를 사용하여 추첨 시점에 배출 확률 테이블을 동적으로 선택하며, 10연 가챠에서 1회만 다른 배출 확률 테이블을 적용하는 등의 시나리오를 구현할 수 있습니다.prize_table: 정적 배출 확률 테이블 / script: GS2-Script를 사용한 동적 배출 확률 테이블 / |
| prizeTableName | string | {method} == "prize_table" | ✓※| | ~ 128자 | 배출 확률 테이블 이름
이 추첨 모델에서 사용할 배출 확률 테이블의 이름입니다. 추첨 방법이 "prize_table"인 경우 필수입니다.
※ method이(가) "prize_table" 이면 필수 |
| choicePrizeTableScriptId | string | {method} == "script" | ✓※| | ~ 1024자 | 배출 확률 테이블을 결정하는 GS2-Script의 스크립트 GRN
Script 트리거 레퍼런스 - [`choicePrizeTable`](../script/#choiceprizetable)
※ method이(가) "script" 이면 필수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | 작성한 추첨 모델 마스터 |
#### 구현 예제
**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
추첨 모델 마스터 취득
지정된 추첨 모델 마스터의 모드(normal/box), 추첨 방식(prizeTable/script), 관련된 배출 확률 테이블 또는 스크립트 설정을 포함한 정보를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| lotteryName | string | | ✓| | ~ 128자 | 추첨 모델 이름
추첨 모델 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | 추첨 모델 마스터 |
#### 구현 예제
**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
추첨 모델 마스터 갱신
지정된 추첨 모델 마스터를 갱신합니다. 설명, 메타데이터, 모드(normal/box), 추첨 방식(prizeTable/script), 배출 확률 테이블 이름, 스크립트 설정을 변경할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| lotteryName | string | | ✓| | ~ 128자 | 추첨 모델 이름
추첨 모델 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 2048자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| mode | 문자열 열거형
enum {
"normal",
"box"
}
| | ✓| | | 추첨 모드
경품의 추첨 방식을 선택합니다. "normal"은 매번 일정한 확률로 추첨을 진행합니다(경품은 반복해서 배출됩니다). "box"는 가상의 상자에 미리 정해진 수량의 경품을 넣어두고, 추첨할 때마다 상자에서 경품을 꺼냅니다(모든 경품이 최종적으로 배출되는 것이 보장됩니다).normal: 일반 추첨 / box: 박스 추첨 / |
| method | 문자열 열거형
enum {
"prize_table",
"script"
}
| | ✓| | | 추첨 방법
배출 확률 테이블의 참조 방법을 결정합니다. "prize_table"은 정적으로 지정된 배출 확률 테이블을 사용합니다.
"script"는 GS2-Script를 사용하여 추첨 시점에 배출 확률 테이블을 동적으로 선택하며, 10연 가챠에서 1회만 다른 배출 확률 테이블을 적용하는 등의 시나리오를 구현할 수 있습니다.prize_table: 정적 배출 확률 테이블 / script: GS2-Script를 사용한 동적 배출 확률 테이블 / |
| prizeTableName | string | {method} == "prize_table" | ✓※| | ~ 128자 | 배출 확률 테이블 이름
이 추첨 모델에서 사용할 배출 확률 테이블의 이름입니다. 추첨 방법이 "prize_table"인 경우 필수입니다.
※ method이(가) "prize_table" 이면 필수 |
| choicePrizeTableScriptId | string | {method} == "script" | ✓※| | ~ 1024자 | 배출 확률 테이블을 결정하는 GS2-Script의 스크립트 GRN
Script 트리거 레퍼런스 - [`choicePrizeTable`](../script/#choiceprizetable)
※ method이(가) "script" 이면 필수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | 갱신한 추첨 모델 마스터 |
#### 구현 예제
**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
추첨 모델 마스터 삭제
지정된 추첨 모델 마스터를 삭제합니다.
다음 마스터 데이터 갱신까지 현재 활성화된 마스터 데이터에는 영향을 주지 않습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| lotteryName | string | | ✓| | ~ 128자 | 추첨 모델 이름
추첨 모델 고유 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [LotteryModelMaster](#lotterymodelmaster) | 삭제한 추첨 모델 마스터 |
#### 구현 예제
**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
배출 확률 테이블 마스터 목록을 취득
지정한 네임스페이스의 배출 확률 테이블 마스터를 페이지네이션으로 취득합니다.
이름의 접두사로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| namePrefix | string | | | | ~ 64자 | 배출 확률 테이블 이름의 필터 접두사 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<PrizeTableMaster>](#prizetablemaster) | 배출 확률 테이블 마스터 리스트 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**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
배출 확률 테이블 마스터를 신규 생성
지정한 경품 설정으로 새로운 배출 확률 테이블 마스터를 생성합니다.
각 경품 항목은 경품 ID, 타입, 획득 액션, 배출 가중치, 그리고 선택적인 수량 제한을 정의합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| name | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름
배출 확률 테이블 고유의 이름입니다. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 128자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| prizes | [List<Prize>](#prize) | | ✓| | 1 ~ 100 items | 경품 리스트
이 배출 확률 테이블 내의 경품 리스트입니다. 각 경품은 배출 가중치(확률), 배출 시 실행할 액션, 그리고 선택적으로 배출 횟수 제한을 정의합니다. 각 경품의 실제 배출 확률은 해당 가중치를 테이블 내 전체 경품 가중치의 합으로 나누어 산출됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | 생성한 배출 확률 테이블 마스터 |
#### 구현 예제
**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
배출 확률 테이블 마스터를 취득
지정한 배출 확률 테이블 마스터의 경품 리스트, 배출 가중치, 타입, 수량 제한을 포함한 정보를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름
배출 확률 테이블 고유의 이름입니다. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | 배출 확률 테이블 마스터 |
#### 구현 예제
**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
배출 확률 테이블 마스터를 업데이트
지정한 배출 확률 테이블 마스터를 업데이트합니다. 설명, 메타데이터, 그리고 경품 리스트의 배출 가중치와 수량 제한을 변경할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름
배출 확률 테이블 고유의 이름입니다. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 128자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| prizes | [List<Prize>](#prize) | | ✓| | 1 ~ 100 items | 경품 리스트
이 배출 확률 테이블 내의 경품 리스트입니다. 각 경품은 배출 가중치(확률), 배출 시 실행할 액션, 그리고 선택적으로 배출 횟수 제한을 정의합니다. 각 경품의 실제 배출 확률은 해당 가중치를 테이블 내 전체 경품 가중치의 합으로 나누어 산출됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | 업데이트한 배출 확률 테이블 마스터 |
#### 구현 예제
**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
배출 확률 테이블 마스터를 삭제
지정한 배출 확률 테이블 마스터를 삭제합니다.
다음 마스터 데이터 업데이트까지는 현재 활성화된 마스터 데이터에 영향을 주지 않습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| prizeTableName | string | | ✓| | ~ 128자 | 배출 확률 테이블 이름
배출 확률 테이블 고유의 이름입니다. 영숫자 및 -(하이픈), _(언더스코어), .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [PrizeTableMaster](#prizetablemaster) | 삭제한 배출 확률 테이블 마스터 |
#### 구현 예제
**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;
```
---