> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Ranking2 SDK API 레퍼런스
각종 프로그래밍 언어용 GS2-Ranking2 SDK의 모델 사양과 API 레퍼런스
## 모델
### Namespace
네임스페이스
네임스페이스는 하나의 프로젝트 내에서 동일한 서비스를 서로 다른 용도로 여러 개 이용하기 위한 엔티티입니다.
GS2의 각 서비스는 네임스페이스 단위로 관리됩니다. 네임스페이스가 다르면 동일한 서비스라도 완전히 독립된 데이터 공간으로 취급됩니다.
따라서 각 서비스의 이용을 시작하려면 먼저 네임스페이스를 생성해야 합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024자 | 네임스페이스 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | ✓ | | | 트랜잭션 설정
랭킹 보상 지급에 사용되는 분산 트랜잭션 설정입니다. 입수 액션을 자동으로 실행하는 오토런, 전체의 성패를 보장하는 아토믹 커밋을 지원합니다. |
| 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" 이면 필수 |
**관련 메서드:**
updateCurrentRankingMasterFromGitHub - 현재 활성화된 랭킹 모델의 마스터 데이터를 GitHub에서 업데이트
---
### GlobalRankingScore
글로벌 랭킹 스코어
특정 시즌의 글로벌 랭킹에서 사용자의 등록 스코어를 저장합니다. 합산 모드가 활성화된 경우, 여러 개의 등록 스코어가 누적됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| globalRankingScoreId | string | | ※ | | ~ 1024자 | 글로벌 랭킹 스코어 GRN
※ 서버가 자동으로 설정 |
| rankingName | string | | ✓ | | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| season | long | | ✓ | | 0 ~ 9223372036854775805 | 시즌
GS2-Schedule 이벤트의 반복 횟수에 대응하는 시즌 번호입니다. 새로운 랭킹 기간마다 증가합니다. |
| score | long | | ✓ | | 0 ~ 9223372036854775805 | 스코어
사용자가 등록한 스코어 값입니다. 랭킹 모델의 minimumValue와 maximumValue로 정의된 범위 내에 있어야 합니다. |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeGlobalRankingScores - 글로벌 랭킹 스코어 목록 조회
describeGlobalRankingScoresByUserId - 사용자 ID를 지정하여 글로벌 랭킹 스코어 목록 조회
putGlobalRankingScore - 글로벌 랭킹 스코어 등록
putGlobalRankingScoreByUserId - 사용자 ID를 지정하여 글로벌 랭킹 스코어 등록
getGlobalRankingScore - 글로벌 랭킹 스코어 조회
getGlobalRankingScoreByUserId - 사용자 ID를 지정하여 글로벌 랭킹 스코어 조회
deleteGlobalRankingScoreByUserId - 사용자 ID를 지정하여 글로벌 랭킹 스코어 삭제
verifyGlobalRankingScore - 글로벌 랭킹의 스코어 검증
verifyGlobalRankingScoreByUserId - 사용자 ID를 지정하여 글로벌 랭킹의 스코어 검증
---
### GlobalRankingReceivedReward
글로벌 랭킹 보상 수령 이력
글로벌 랭킹의 순위에 대해 보상을 설정할 수 있습니다.
보상을 설정하려면 순위 임계값과 보상 내용을 설정합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| globalRankingReceivedRewardId | string | | ※ | | ~ 1024자 | 글로벌 랭킹 보상 수령 이력 GRN
※ 서버가 자동으로 설정 |
| rankingName | string | | ✓ | | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| season | long | | ✓ | | 0 ~ 9223372036854775805 | 시즌
GS2-Schedule 이벤트의 반복 횟수에 대응하는 시즌 번호입니다. 새로운 랭킹 기간마다 증가합니다. |
| receivedAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeGlobalRankingReceivedRewards - 글로벌 랭킹 보상 수령 이력 목록 취득
describeGlobalRankingReceivedRewardsByUserId - 사용자 ID를 지정하여 글로벌 랭킹 보상 수령 이력 목록 취득
createGlobalRankingReceivedReward - 글로벌 랭킹 보상 수령 이력 기록
createGlobalRankingReceivedRewardByUserId - 사용자 ID를 지정하여 글로벌 랭킹 보상 수령 이력 기록
getGlobalRankingReceivedReward - 글로벌 랭킹 보상 수령 이력 취득
getGlobalRankingReceivedRewardByUserId - 사용자 ID를 지정하여 글로벌 랭킹 보상 수령 이력 취득
deleteGlobalRankingReceivedRewardByUserId - 사용자 ID를 지정하여 글로벌 랭킹 보상 수령 이력 삭제
---
### GlobalRankingData
글로벌 랭킹
특정 시즌의 글로벌 랭킹에서의 랭킹 엔트리를 나타냅니다. 사용자의 스코어, 0부터 시작하는 인덱스(정렬 위치), 1부터 시작하는 순위(동점을 고려)를 포함합니다. 순위는 인덱스 + 1로 계산됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| globalRankingDataId | string | | ※ | | ~ 1024자 | 글로벌 랭킹 GRN
※ 서버가 자동으로 설정 |
| rankingName | string | | ✓ | | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | ✓ | | 0 ~ 9223372036854775805 | 시즌
GS2-Schedule 이벤트의 반복 횟수에 대응하는 시즌 번호입니다. 새로운 랭킹 기간마다 증가합니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| index | int | | | | 0 ~ 2147483646 | 인덱스
랭킹 내 이 엔트리의 0부터 시작하는 고유한 정렬 위치입니다. 순위와 달리, 스코어가 동점이어도 인덱스는 항상 고유합니다. 인덱스 기반 보상 계산에 사용됩니다. |
| rank | int | | | | 0 ~ 2147483646 | 순위
1부터 시작하는 랭킹 순위입니다. 스코어가 같은 플레이어는 동일한 순위를 공유합니다. 인덱스 + 1로 계산됩니다. 순위 기반 보상 계산에 사용됩니다. |
| score | long | | ✓ | | 0 ~ 9223372036854775805 | 스코어 |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| invertUpdatedAt | long | | ✓ | | 0 ~ 9223372036854775805 | updatedAt의 반전 값(정렬용 내부 값) |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeGlobalRankings - 글로벌 랭킹 목록 조회
describeGlobalRankingsByUserId - 사용자 ID를 지정하여 글로벌 랭킹 목록 조회
getGlobalRanking - 글로벌 랭킹 조회
getGlobalRankingByUserId - 사용자 ID를 지정하여 글로벌 랭킹 조회
---
### ClusterRankingScore
클러스터 랭킹 스코어
특정 시즌·클러스터에서의 사용자 등록 스코어를 저장합니다. 스코어 접수 전에 클러스터 타입 설정에 따라 사용자의 클러스터 소속이 검증됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| clusterRankingScoreId | string | | ※ | | ~ 1024자 | 클러스터 랭킹 스코어 GRN
※ 서버가 자동으로 설정 |
| rankingName | string | | ✓ | | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓ | | ~ 1024자 | 클러스터 이름
이 스코어가 속한 클러스터(길드, 개더링, 또는 임의의 그룹)의 이름입니다. 클러스터 타입 설정에 따라 사용자의 소속이 검증됩니다. |
| season | long | | ✓ | | 0 ~ 9223372036854775805 | 시즌
GS2-Schedule 이벤트의 반복 횟수에 대응하는 시즌 번호입니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| score | long | | ✓ | | 0 ~ 9223372036854775805 | 스코어
이 클러스터 내에서 사용자가 등록한 스코어 값입니다. |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeClusterRankingScores - 클러스터 랭킹 스코어 목록 취득
describeClusterRankingScoresByUserId - 사용자 ID를 지정하여 클러스터 랭킹 스코어 목록 취득
putClusterRankingScore - 클러스터 랭킹 스코어 등록
putClusterRankingScoreByUserId - 사용자 ID를 지정하여 클러스터 랭킹 스코어 등록
getClusterRankingScore - 클러스터 랭킹 스코어 취득
getClusterRankingScoreByUserId - 사용자 ID를 지정하여 클러스터 랭킹 스코어 취득
deleteClusterRankingScoreByUserId - 사용자 ID를 지정하여 클러스터 랭킹 스코어 삭제
verifyClusterRankingScore - 클러스터 랭킹의 스코어 검증
verifyClusterRankingScoreByUserId - 사용자 ID를 지정하여 클러스터 랭킹의 스코어 검증
---
### ClusterRankingReceivedReward
클러스터 랭킹 보상 수령 이력
클러스터 랭킹 순위에 따른 보상을 설정할 수 있습니다.
보상을 설정하려면 순위 임계값과 보상 내용을 설정합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| clusterRankingReceivedRewardId | string | | ※ | | ~ 1024자 | 클러스터 랭킹 보상 수령 이력 GRN
※ 서버가 자동으로 설정 |
| rankingName | string | | ✓ | | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓ | | ~ 1024자 | 클러스터 이름
랭킹 보상을 수령한 클러스터의 이름입니다. |
| season | long | | ✓ | | 0 ~ 9223372036854775805 | 시즌
GS2-Schedule 이벤트의 반복 횟수에 대응하는 시즌 번호입니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| receivedAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeClusterRankingReceivedRewards - 클러스터 랭킹 보상 수령 이력 목록 조회
describeClusterRankingReceivedRewardsByUserId - 사용자 ID를 지정하여 클러스터 랭킹 보상 수령 이력 목록 조회
createClusterRankingReceivedReward - 클러스터 랭킹 보상 수령 이력 기록
createClusterRankingReceivedRewardByUserId - 사용자 ID를 지정하여 클러스터 랭킹 보상 수령 이력 기록
getClusterRankingReceivedReward - 클러스터 랭킹 보상 수령 이력 조회
getClusterRankingReceivedRewardByUserId - 사용자 ID를 지정하여 클러스터 랭킹 보상 수령 이력 조회
deleteClusterRankingReceivedRewardByUserId - 사용자 ID를 지정하여 클러스터 랭킹 보상 수령 이력 삭제
---
### ClusterRankingData
클러스터 랭킹
특정 시즌·클러스터에서의 클러스터 랭킹의 랭킹 엔트리를 나타냅니다. 클러스터 내 사용자의 스코어, 0부터 시작하는 인덱스, 1부터 시작하는 순위를 포함합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| clusterRankingDataId | string | | ※ | | ~ 1024자 | 클러스터 랭킹 GRN
※ 서버가 자동으로 설정 |
| rankingName | string | | ✓ | | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓ | | ~ 1024자 | 클러스터 이름
이 시즌이 속한 클러스터(길드, 게더링, 또는 그룹)의 이름입니다. |
| season | long | | ✓ | | 0 ~ 9223372036854775805 | 시즌
GS2-Schedule 이벤트의 반복 횟수에 대응하는 시즌 번호입니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| index | int | | | | 0 ~ 2147483646 | 인덱스
클러스터 랭킹 내에서 0부터 시작하는 고유한 정렬 위치입니다. 스코어가 동점이어도 항상 고유합니다. |
| rank | int | | | | 0 ~ 2147483646 | 순위
클러스터 내에서 1부터 시작하는 랭킹 순위입니다. 스코어가 같은 플레이어는 동일한 순위를 공유합니다. 인덱스 + 1로 계산됩니다. |
| score | long | | ✓ | | 0 ~ 9223372036854775805 | 스코어 |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| invertUpdatedAt | long | | ✓ | | 0 ~ 9223372036854775805 | updatedAt의 반전 값(정렬용 내부 값) |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeClusterRankings - 클러스터 랭킹 목록 조회
describeClusterRankingsByUserId - 사용자 ID를 지정하여 클러스터 랭킹 목록 조회
getClusterRanking - 클러스터 랭킹 조회
getClusterRankingByUserId - 사용자 ID를 지정하여 클러스터 랭킹 조회
---
### Subscribe
구독
다른 플레이어를 구독 대상으로 등록하면, 해당 플레이어의 최신 스코어를 자신의 랭킹 보드에 반영할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| subscribeId | string | | ※ | | ~ 1024자 | 스코어 구독 GRN
※ 서버가 자동으로 설정 |
| rankingName | string | | ✓ | | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| targetUserIds | List<string> | | | [] | 0 ~ 1000 items | 구독 대상 사용자 ID
이 사용자가 구독하고 있는 사용자 ID 목록입니다. 구독 대상 사용자의 스코어가 이 사용자의 구독 랭킹에 표시됩니다. 최대 1000명까지 구독할 수 있으며, 중복 구독은 방지됩니다. |
| fromUserIds | List<string> | | | [] | 0 ~ 1000 items | 피구독 사용자 ID
이 사용자를 구독하고 있는 사용자 ID 목록입니다. targetUserIds의 역방향 관계로, 어떤 사용자가 이 사용자의 스코어를 팔로우하고 있는지를 추적합니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
---
### SubscribeRankingScore
구독 랭킹 스코어
특정 시즌의 구독 랭킹에서 사용자가 등록한 점수를 저장합니다. 이 점수는 이 사용자를 구독하고 있는 사용자에게 표시되어 맞춤형 친구 랭킹을 구성합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| subscribeRankingScoreId | string | | ※ | | ~ 1024자 | 구독 랭킹 스코어 GRN
※ 서버가 자동으로 설정 |
| rankingName | string | | ✓ | | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | ✓ | | 0 ~ 9223372036854775805 | 시즌
GS2-Schedule 이벤트의 반복 횟수에 대응하는 시즌 번호입니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| score | long | | ✓ | | 0 ~ 9223372036854775805 | 스코어 |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeSubscribeRankingScores - 구독 랭킹 스코어 목록 취득
describeSubscribeRankingScoresByUserId - 사용자 ID를 지정하여 구독 랭킹 스코어 목록 취득
putSubscribeRankingScore - 구독 랭킹 스코어 등록
putSubscribeRankingScoreByUserId - 사용자 ID를 지정하여 구독 랭킹 스코어 등록
getSubscribeRankingScore - 구독 랭킹 스코어 취득
getSubscribeRankingScoreByUserId - 사용자 ID를 지정하여 구독 랭킹 스코어 취득
deleteSubscribeRankingScoreByUserId - 사용자 ID를 지정하여 구독 랭킹 스코어 삭제
verifySubscribeRankingScore - 구독 랭킹의 스코어를 검증
verifySubscribeRankingScoreByUserId - 사용자 ID를 지정하여 구독 랭킹의 스코어를 검증
---
### SubscribeRankingData
구독 랭킹
특정 시즌의 사용자별 맞춤 구독 랭킹에서의 랭킹 엔트리를 나타냅니다. 구독한 사용자의 점수를 포함하며, 친구 목록 내에서 순위가 매겨집니다. 각 엔트리에는 점수를 달성한 사용자ID가 포함됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| subscribeRankingDataId | string | | ※ | | ~ 1024자 | 구독 랭킹 GRN
※ 서버가 자동으로 설정 |
| rankingName | string | | ✓ | | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | ✓ | | 0 ~ 9223372036854775805 | 시즌
GS2-Schedule 이벤트의 반복 횟수에 대응하는 시즌 번호입니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| index | int | | | | 0 ~ 2147483646 | 인덱스
구독 랭킹 내에서 0부터 시작하는 고유한 정렬 위치입니다. |
| rank | int | | | | 0 ~ 2147483646 | 순위
구독 랭킹 내에서 1부터 시작하는 랭킹 순위입니다. 인덱스 + 1로 계산됩니다. |
| scorerUserId | string | | ✓ | | ~ 128자 | 점수를 획득한 사용자ID
이 점수를 달성한 플레이어의 사용자ID입니다. 구독 랭킹에서는 구독한 사용자의 점수가 엔트리가 되므로, 이 필드는 어느 친구의 점수인지를 식별합니다. |
| score | long | | ✓ | | 0 ~ 9223372036854775805 | 스코어 |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| invertUpdatedAt | long | | ✓ | | 0 ~ 9223372036854775805 | updatedAt의 반전 값(정렬용 내부 값) |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeSubscribeRankings - 구독 랭킹 목록 취득
describeSubscribeRankingsByUserId - 사용자 ID를 지정하여 구독 랭킹 목록 취득
getSubscribeRanking - 구독 랭킹 취득
getSubscribeRankingByUserId - 사용자 ID를 지정하여 구독 랭킹 취득
---
### SubscribeUser
구독 대상 사용자 정보
구독 랭킹에서 두 사용자 간의 구독 관계를 나타냅니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| rankingName | string | | ✓ | | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| targetUserId | string | | ✓ | | ~ 128자 | 구독 대상 사용자 ID
구독 대상 플레이어의 사용자 ID입니다. 이 플레이어의 스코어가 구독자의 개인화된 랭킹에 포함됩니다. |
**관련 메서드:**
describeSubscribes - 구독 대상 사용자 정보 목록 취득
describeSubscribesByUserId - 사용자 ID를 지정하여 구독 대상 사용자 정보 목록 취득
addSubscribe - 구독 대상 사용자 ID 등록
addSubscribeByUserId - 사용자 ID를 지정하여 구독 대상 사용자 ID 등록
getSubscribe - 구독 대상 사용자 ID 취득
getSubscribeByUserId - 사용자 ID를 지정하여 구독 대상 사용자 ID 취득
deleteSubscribe - 구독 대상 사용자 ID 삭제
deleteSubscribeByUserId - 사용자 ID를 지정하여 구독 대상 사용자 ID 삭제
---
### GlobalRankingModel
글로벌 랭킹 모델
글로벌 랭킹은 모든 플레이어를 대상으로 한 랭킹을 구현하기 위한 모델입니다.
상위 1000위까지의 랭킹을 표시할 수 있습니다.
GS2-Schedule의 반복 이벤트와 연결하면 반복 횟수에 따라 랭킹을 초기화할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| globalRankingModelId | string | | ※ | | ~ 1024자 | 글로벌 랭킹 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 스코어 최솟값
허용되는 스코어의 최솟값입니다. 이 값보다 낮은 스코어는 등록 시 거부됩니다. 유효하지 않거나 의도하지 않은 스코어 값을 필터링하는 데 사용합니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 스코어 최댓값
허용되는 스코어의 최댓값입니다. 이 값을 초과하는 스코어는 등록 시 거부됩니다. 비정상적으로 높은 스코어의 등록을 방지하는 데 사용합니다. |
| sum | bool | | | false | | 스코어 합산
활성화하면 등록된 모든 스코어가 합산되어 합계 값으로 랭킹이 결정됩니다. 비활성화된 경우, 정렬 방향에 따른 최적의 스코어(최댓값 또는 최솟값)만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓ | | | 정렬 방향
랭킹 스코어의 정렬 방향입니다. 낮은 스코어일수록 상위인 경우(예: 타임어택)에는 "오름차순"을, 높은 스코어일수록 상위인 경우(예: 하이스코어)에는 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 반복 사이클마다 랭킹이 초기화되어 시즌제 랭킹을 구현할 수 있습니다. |
| rankingRewards | [List<RankingReward>](#rankingreward) | {entryPeriodEventId} != null | | [] | 0 ~ 100 items | 랭킹 보상 목록
각 시즌 종료 시의 랭킹 순위에 따라 지급되는 보상 목록입니다. 스코어 등록 가능 기간 이벤트가 설정되어 있는 경우에만 이용할 수 있습니다. 각 보상은 순위 임계값과 실행할 입수 액션을 정의합니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과의 열람과 보상 수령이 가능한 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 일반적으로 스코어 등록 기간 사이의 간격으로 설정합니다. |
| rewardCalculationIndex | 문자열 열거형
enum {
"rank",
"index"
}
| | | "rank" | | 보상 계산 인덱스
보상을 플레이어에게 대응시키는 방법을 결정합니다. "순위 기반"은 1부터 시작하는 랭킹 순위를 사용하며(동점 스코어의 플레이어는 동일한 순위를 공유), "인덱스 기반"은 0부터 시작하는 고유한 정렬 위치를 사용합니다(동일 순위 없음). 일반적인 사용 사례에서는 "순위 기반"을 선택하시기 바랍니다.rank: 순위 기반으로 보상 결정 / index: 인덱스 기반으로 보상 결정 / |
**관련 메서드:**
receiveGlobalRankingReceivedReward - 글로벌 랭킹 보상 수령
receiveGlobalRankingReceivedRewardByUserId - 사용자 ID를 지정하여 글로벌 랭킹 보상 수령
describeGlobalRankingModels - 글로벌 랭킹 모델 목록 취득
getGlobalRankingModel - 글로벌 랭킹 모델 취득
---
### ClusterRankingModel
클러스터 랭킹 모델
클러스터 랭킹은 길드나 게더링 내의 플레이어를 대상으로 하는 랭킹을 구현하기 위한 모델입니다.
상위 1000위까지의 랭킹을 표시할 수 있습니다.
GS2-Schedule의 반복 이벤트와 연동하면 반복 횟수에 따라 랭킹을 초기화할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| clusterRankingModelId | string | | ※ | | ~ 1024자 | 클러스터 랭킹 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| clusterType | 문자열 열거형
enum {
"Raw",
"Gs2Guild::Guild",
"Gs2Matchmaking::SeasonGathering"
}
| | ✓ | | | 클러스터 타입
랭킹의 세그멘테이션에 사용하는 그룹(클러스터)의 종류를 정의합니다. "Raw"는 소속 검증 없이 임의의 클러스터 이름을 지정할 수 있으며, "Gs2Guild::Guild"는 GS2-Guild 길드에 대한 소속을 검증하고, "Gs2Matchmaking::SeasonGathering"은 GS2-Matchmaking 시즌 개더링에 대한 소속을 검증합니다.Raw: 검증 없음 / Gs2Guild::Guild: GS2-Guild 길드 / Gs2Matchmaking::SeasonGathering: GS2-Matchmaking 시즌 개더링 / |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 최소 점수
허용되는 점수의 최소값입니다. 이 값보다 낮은 점수는 등록 시 거부됩니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 최대 점수
허용되는 점수의 최대값입니다. 이 값을 초과하는 점수는 등록 시 거부됩니다. |
| sum | bool | | | false | | 점수 합산
활성화하면 등록된 모든 점수가 합산되어 합계값으로 랭킹이 결정됩니다. 비활성화된 경우 최고 점수만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓ | | | 정렬 방향
랭킹 점수의 정렬 방향입니다. 점수가 낮을수록 상위인 경우 "오름차순", 점수가 높을수록 상위인 경우 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 시즌제 랭킹을 구현할 수 있습니다. |
| rankingRewards | [List<RankingReward>](#rankingreward) | {entryPeriodEventId} != null | | [] | 0 ~ 100 items | 랭킹 보상 목록
각 시즌 종료 시의 랭킹 순위에 따라 지급되는 보상 목록입니다. 스코어 등록 가능 기간 이벤트가 설정되어 있는 경우에만 이용할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과의 열람과 보상 수령이 가능한 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. |
| rewardCalculationIndex | 문자열 열거형
enum {
"rank",
"index"
}
| | | "rank" | | 보상 계산 인덱스
보상을 플레이어에게 대응시키는 방법을 결정합니다. "순위 기반"은 1부터 시작하는 랭킹 순위(동점 스코어는 동일 순위), "인덱스 기반"은 0부터 시작하는 고유한 정렬 위치(동일 순위 없음)를 사용합니다.rank: 순위 기반으로 보상 결정 / index: 인덱스 기반으로 보상 결정 / |
**관련 메서드:**
receiveClusterRankingReceivedReward - 클러스터 랭킹 보상 수령
receiveClusterRankingReceivedRewardByUserId - 사용자 ID를 지정하여 클러스터 랭킹 보상 수령
describeClusterRankingModels - 클러스터 랭킹 모델 목록 조회
getClusterRankingModel - 클러스터 랭킹 모델 조회
---
### SubscribeRankingModel
구독 랭킹 모델
구독한 다른 플레이어의 점수를 집계하여 랭킹을 작성하는 모델입니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| subscribeRankingModelId | string | | ※ | | ~ 1024자 | 구독 랭킹 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 최소 점수
허용되는 점수의 최소값입니다. 이 값보다 낮은 점수는 등록 시 거부됩니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 최대 점수
허용되는 점수의 최대값입니다. 이 값을 초과하는 점수는 등록 시 거부됩니다. |
| sum | bool | | | false | | 점수 합산
활성화하면 등록된 모든 점수가 합산되어 합계값으로 랭킹이 결정됩니다. 비활성화된 경우 최고 점수만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓ | | | 정렬 방향
랭킹 점수의 정렬 방향입니다. 점수가 낮을수록 상위인 경우 "오름차순", 점수가 높을수록 상위인 경우 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 시즌제 랭킹을 구현할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과를 열람할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. |
**관련 메서드:**
describeSubscribeRankingModels - 구독 랭킹 모델 목록 조회
getSubscribeRankingModel - 구독 랭킹 모델 조회
---
### RankingReward
랭킹 보상
점수 등록 기간이 설정된 랭킹에서, 등록 기간 외 참조 기간 내에 받을 수 있는 보상을 설정합니다.
반복 설정이 유효한 경우, 가장 최근에 종료된 기간의 랭킹이 보상 수령 대상이 됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| thresholdRank | int | | ✓ | | 1 ~ 1001 | 순위 임계값
이 보상 티어의 순위 임계값입니다. 순위(또는 인덱스, rewardCalculationIndex 설정에 따라 다름)가 이 임계값 이상인 플레이어가 이 보상을 받습니다. 1001로 설정하면 랭크 외(상위 1000위 밖) 플레이어를 위한 보상을 정의할 수 있습니다. |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| acquireActions | [List<AcquireAction>](#acquireaction) | | | [] | 0 ~ 100 items | 입수 액션 리스트
플레이어가 이 랭킹 보상을 수령할 때 실행되는 입수 액션의 목록입니다. 이 순위 임계값을 달성한 보상으로 지급되는 아이템, 화폐, 기타 리소스를 정의합니다. |
**관련 모델:**
GlobalRankingModel - 글로벌 랭킹 모델
ClusterRankingModel - 클러스터 랭킹 모델
GlobalRankingModelMaster - 글로벌 랭킹 모델 마스터
ClusterRankingModelMaster - 클러스터 랭킹 모델 마스터
---
### 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 | | 트랜잭션 실행 중 오류가 발생했는지 여부 |
**관련 메서드:**
receiveGlobalRankingReceivedReward - 글로벌 랭킹 보상 수령
receiveGlobalRankingReceivedRewardByUserId - 사용자 ID를 지정하여 글로벌 랭킹 보상 수령
receiveClusterRankingReceivedReward - 클러스터 랭킹 보상 수령
receiveClusterRankingReceivedRewardByUserId - 사용자 ID를 지정하여 클러스터 랭킹 보상 수령
---
### AcquireAction
입수 액션
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| action | 문자열 열거형
enum {
}
| | ✓ | | | 입수 액션에서 실행할 액션의 종류 |
| request | string | | ✓ | | ~ 524288자 | 액션 실행 시 사용되는 요청의 JSON 문자열 |
**관련 메서드:**
receiveGlobalRankingReceivedReward - 글로벌 랭킹 보상 수령
receiveGlobalRankingReceivedRewardByUserId - 사용자 ID를 지정하여 글로벌 랭킹 보상 수령
receiveClusterRankingReceivedReward - 클러스터 랭킹 보상 수령
receiveClusterRankingReceivedRewardByUserId - 사용자 ID를 지정하여 클러스터 랭킹 보상 수령
**관련 모델:**
RankingReward - 랭킹 보상
---
### Config
컨피그 설정
트랜잭션의 변수에 적용하는 설정 값
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| key | string | | ✓ | | ~ 64자 | 이름 |
| value | string | | | | ~ 51200자 | 값 |
---
### CurrentRankingMaster
현재 활성화된 랭킹 모델의 마스터 데이터
현재 네임스페이스 내에서 유효한 랭킹 모델의 정의를 기술한 마스터 데이터입니다.
GS2에서는 마스터 데이터 관리에 JSON 형식의 파일을 사용합니다.
파일을 업로드함으로써 실제로 서버에 설정을 반영할 수 있습니다.
JSON 파일을 작성하는 방법으로, 관리 콘솔 내에 마스터 데이터 에디터를 제공하고 있습니다.
또한 게임 운영에 더 적합한 도구를 제작하여 적절한 형식의 JSON 파일을 출력하는 방법으로도 서비스를 이용할 수 있습니다.
**ℹ️ Note**
JSON 파일 형식에 대해서는 [GS2-Ranking2 마스터 데이터 레퍼런스](api_reference/ranking2/master_data/)를 참조해 주세요.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024자 | 네임스페이스 GRN
※ 서버가 자동으로 설정 |
| settings | string | | ✓ | | ~ 5242880 바이트 (5MB) | 마스터 데이터 |
**관련 메서드:**
exportMaster - 활성화 가능한 마스터 데이터 형식으로 모델 마스터 내보내기
getCurrentRankingMaster - 현재 활성화된 랭킹 모델의 마스터 데이터 조회
updateCurrentRankingMaster - 현재 활성화된 랭킹 모델의 마스터 데이터 업데이트
updateCurrentRankingMasterFromGitHub - 현재 활성화된 랭킹 모델의 마스터 데이터를 GitHub에서 업데이트
---
### GlobalRankingModelMaster
글로벌 랭킹 모델 마스터
글로벌 랭킹 모델 마스터는 게임 내에서 사용되는 글로벌 랭킹 모델의 편집·관리용 데이터로, 관리 콘솔의 마스터 데이터 에디터에서 일시적으로 보관됩니다.
임포트·업데이트 처리를 수행함으로써 실제로 게임에서 참조되는 글로벌 랭킹 모델로 반영됩니다.
글로벌 랭킹 모델은 모든 플레이어를 대상으로 하는 랭킹을 구현하기 위한 모델입니다.
상위 1000위까지의 랭킹을 표시할 수 있습니다.
GS2-Schedule의 반복 이벤트와 연동하면 반복 횟수에 따라 랭킹을 초기화할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| globalRankingModelId | string | | ※ | | ~ 1024자 | 글로벌 랭킹 마스터 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 스코어 최솟값
허용되는 스코어의 최솟값입니다. 이 값보다 낮은 스코어는 등록 시 거부됩니다. 유효하지 않거나 의도하지 않은 스코어 값을 필터링하는 데 사용합니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 스코어 최댓값
허용되는 스코어의 최댓값입니다. 이 값을 초과하는 스코어는 등록 시 거부됩니다. 비정상적으로 높은 스코어의 등록을 방지하는 데 사용합니다. |
| sum | bool | | | false | | 스코어 합산
활성화하면 등록된 모든 스코어가 합산되어 합계 값으로 랭킹이 결정됩니다. 비활성화된 경우, 정렬 방향에 따른 최적의 스코어(최댓값 또는 최솟값)만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓ | | | 정렬 방향
랭킹 스코어의 정렬 방향입니다. 낮은 스코어일수록 상위인 경우(예: 타임어택)에는 "오름차순"을, 높은 스코어일수록 상위인 경우(예: 하이스코어)에는 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 반복 사이클마다 랭킹이 초기화되어 시즌제 랭킹을 구현할 수 있습니다. |
| rankingRewards | [List<RankingReward>](#rankingreward) | {entryPeriodEventId} != null | | [] | 0 ~ 100 items | 랭킹 보상 목록
각 시즌 종료 시의 랭킹 순위에 따라 지급되는 보상 목록입니다. 스코어 등록 가능 기간 이벤트가 설정되어 있는 경우에만 이용할 수 있습니다. 각 보상은 순위 임계값과 실행할 입수 액션을 정의합니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과의 열람과 보상 수령이 가능한 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 일반적으로 스코어 등록 기간 사이의 간격으로 설정합니다. |
| rewardCalculationIndex | 문자열 열거형
enum {
"rank",
"index"
}
| | | "rank" | | 보상 계산 인덱스
보상을 플레이어에게 대응시키는 방법을 결정합니다. "순위 기반"은 1부터 시작하는 랭킹 순위를 사용하며(동점 스코어의 플레이어는 동일한 순위를 공유), "인덱스 기반"은 0부터 시작하는 고유한 정렬 위치를 사용합니다(동일 순위 없음). 일반적인 사용 사례에서는 "순위 기반"을 선택하시기 바랍니다.rank: 순위 기반으로 보상 결정 / index: 인덱스 기반으로 보상 결정 / |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeGlobalRankingModelMasters - 글로벌 랭킹 모델 마스터 목록 조회
createGlobalRankingModelMaster - 글로벌 랭킹 모델 마스터 신규 생성
getGlobalRankingModelMaster - 글로벌 랭킹 모델 마스터 조회
updateGlobalRankingModelMaster - 글로벌 랭킹 모델 마스터 업데이트
deleteGlobalRankingModelMaster - 글로벌 랭킹 모델 마스터 삭제
---
### ClusterRankingModelMaster
클러스터 랭킹 모델 마스터
클러스터 랭킹 모델 마스터는 게임 내에서 사용되는 클러스터 랭킹 모델을 편집·관리하기 위한 데이터로, 매니지먼트 콘솔의 마스터 데이터 에디터에서 일시적으로 보관됩니다.
가져오기·업데이트 처리를 수행하면, 실제로 게임에서 참조되는 클러스터 랭킹 모델로 반영됩니다.
클러스터 랭킹 모델은 길드나 개더링 내 플레이어를 대상으로 한 랭킹을 구현하기 위한 모델입니다.
상위 1000위까지의 랭킹을 표시할 수 있습니다.
GS2-Schedule의 반복 이벤트와 연결하면 반복 횟수에 따라 랭킹을 초기화할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| clusterRankingModelId | string | | ※ | | ~ 1024자 | 클러스터 랭킹 마스터 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| clusterType | 문자열 열거형
enum {
"Raw",
"Gs2Guild::Guild",
"Gs2Matchmaking::SeasonGathering"
}
| | ✓ | | | 클러스터 타입
랭킹의 세그멘테이션에 사용하는 그룹(클러스터)의 종류를 정의합니다. "Raw"는 소속 검증 없이 임의의 클러스터 이름을 지정할 수 있으며, "Gs2Guild::Guild"는 GS2-Guild 길드에 대한 소속을 검증하고, "Gs2Matchmaking::SeasonGathering"은 GS2-Matchmaking 시즌 개더링에 대한 소속을 검증합니다.Raw: 검증 없음 / Gs2Guild::Guild: GS2-Guild 길드 / Gs2Matchmaking::SeasonGathering: GS2-Matchmaking 시즌 개더링 / |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 최소 점수
허용되는 점수의 최소값입니다. 이 값보다 낮은 점수는 등록 시 거부됩니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 최대 점수
허용되는 점수의 최대값입니다. 이 값을 초과하는 점수는 등록 시 거부됩니다. |
| sum | bool | | | false | | 점수 합산
활성화하면 등록된 모든 점수가 합산되어 합계값으로 랭킹이 결정됩니다. 비활성화된 경우 최고 점수만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓ | | | 정렬 방향
랭킹 점수의 정렬 방향입니다. 점수가 낮을수록 상위인 경우 "오름차순", 점수가 높을수록 상위인 경우 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 시즌제 랭킹을 구현할 수 있습니다. |
| rankingRewards | [List<RankingReward>](#rankingreward) | {entryPeriodEventId} != null | | [] | 0 ~ 100 items | 랭킹 보상 목록
각 시즌 종료 시의 랭킹 순위에 따라 지급되는 보상 목록입니다. 스코어 등록 가능 기간 이벤트가 설정되어 있는 경우에만 이용할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과의 열람과 보상 수령이 가능한 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. |
| rewardCalculationIndex | 문자열 열거형
enum {
"rank",
"index"
}
| | | "rank" | | 보상 계산 인덱스
보상을 플레이어에게 대응시키는 방법을 결정합니다. "순위 기반"은 1부터 시작하는 랭킹 순위(동점 스코어는 동일 순위), "인덱스 기반"은 0부터 시작하는 고유한 정렬 위치(동일 순위 없음)를 사용합니다.rank: 순위 기반으로 보상 결정 / index: 인덱스 기반으로 보상 결정 / |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeClusterRankingModelMasters - 클러스터 랭킹 모델 마스터 목록 조회
createClusterRankingModelMaster - 클러스터 랭킹 모델 마스터 신규 생성
getClusterRankingModelMaster - 클러스터 랭킹 모델 마스터 조회
updateClusterRankingModelMaster - 클러스터 랭킹 모델 마스터 갱신
deleteClusterRankingModelMaster - 클러스터 랭킹 모델 마스터 삭제
---
### SubscribeRankingModelMaster
구독 랭킹 모델 마스터
구독 랭킹 모델 마스터는 게임 내에서 사용되는 구독 랭킹 모델의 편집·관리용 데이터로, 매니지먼트 콘솔의 마스터 데이터 에디터에서 일시적으로 보관됩니다.
임포트·갱신 처리를 수행함으로써 실제로 게임에서 참조되는 구독 랭킹 모델로 반영됩니다.
구독 랭킹 모델은 사용자가 구독한 다른 플레이어의 점수를 집계하여 랭킹을 생성하는 모델입니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| subscribeRankingModelId | string | | ※ | | ~ 1024자 | 구독 랭킹 마스터 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 구독 랭킹 모델명
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈), _(밑줄), .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 최소 점수
허용되는 점수의 최소값입니다. 이 값보다 낮은 점수는 등록 시 거부됩니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 최대 점수
허용되는 점수의 최대값입니다. 이 값을 초과하는 점수는 등록 시 거부됩니다. |
| sum | bool | | | false | | 점수 합산
활성화하면 등록된 모든 점수가 합산되어 합계값으로 랭킹이 결정됩니다. 비활성화된 경우 최고 점수만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓ | | | 정렬 방향
랭킹 점수의 정렬 방향입니다. 점수가 낮을수록 상위인 경우 "오름차순", 점수가 높을수록 상위인 경우 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 시즌제 랭킹을 구현할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과를 열람할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeSubscribeRankingModelMasters - 구독 랭킹 모델 마스터 목록 조회
createSubscribeRankingModelMaster - 구독 랭킹 모델 마스터 신규 생성
getSubscribeRankingModelMaster - 구독 랭킹 모델 마스터 조회
updateSubscribeRankingModelMaster - 구독 랭킹 모델 마스터 업데이트
deleteSubscribeRankingModelMaster - 구독 랭킹 모델 마스터 삭제
---
## 메서드
### 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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeNamespacesRequest;
import io.gs2.ranking2.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2Ranking2.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_namespaces(
ranking2.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('ranking2')
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('ranking2')
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) | | ✓| | | 트랜잭션 설정
랭킹 보상 지급에 사용되는 분산 트랜잭션 설정입니다. 입수 액션을 자동으로 실행하는 오토런, 전체의 성패를 보장하는 아토믹 커밋을 지원합니다. |
| 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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&ranking2.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
TransactionSetting: nil,
LogSetting: &ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting(null)
->withLogSetting((new \Gs2\Ranking2\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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CreateNamespaceRequest;
import io.gs2.ranking2.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(null)
.withLogSetting(new io.gs2.ranking2.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2Ranking2.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(null)
.WithLogSetting(new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.createNamespace(
new Gs2Ranking2.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(null)
.withLogSetting(new Gs2Ranking2.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.create_namespace(
ranking2.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_transaction_setting(None)
.with_log_setting(
ranking2.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('ranking2')
api_result = client.create_namespace({
name="namespace-0001",
description=nil,
transactionSetting=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking2')
api_result_handler = client.create_namespace_async({
name="namespace-0001",
description=nil,
transactionSetting=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### getNamespaceStatus
네임스페이스의 상태 조회
지정된 네임스페이스의 현재 상태를 조회합니다.
상태에는 네임스페이스가 활성 상태인지, 삭제되었는지가 포함됩니다.
#### 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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetNamespaceStatusRequest;
import io.gs2.ranking2.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2Ranking2.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_namespace_status(
ranking2.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
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('ranking2')
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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetNamespace(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetNamespaceRequest;
import io.gs2.ranking2.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getNamespace(
new Gs2Ranking2.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_namespace(
ranking2.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
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('ranking2')
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) | | ✓| | | 트랜잭션 설정
랭킹 보상 지급에 사용되는 분산 트랜잭션 설정입니다. 입수 액션을 자동으로 실행하는 오토런, 전체의 성패를 보장하는 아토믹 커밋을 지원합니다. |
| 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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&ranking2.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
TransactionSetting: nil,
LogSetting: &ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting(null)
->withLogSetting((new \Gs2\Ranking2\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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.UpdateNamespaceRequest;
import io.gs2.ranking2.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(null)
.withLogSetting(new io.gs2.ranking2.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2Ranking2.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(null)
.WithLogSetting(new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.updateNamespace(
new Gs2Ranking2.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(null)
.withLogSetting(new Gs2Ranking2.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.update_namespace(
ranking2.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_transaction_setting(None)
.with_log_setting(
ranking2.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('ranking2')
api_result = client.update_namespace({
namespaceName="namespace-0001",
description="description1",
transactionSetting=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking2')
api_result_handler = client.update_namespace_async({
namespaceName="namespace-0001",
description="description1",
transactionSetting=nil,
logSetting={
loggingNamespaceId="grn:gs2:ap-northeast-1:YourOwnerId:log:namespace-0001",
},
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### deleteNamespace
네임스페이스 삭제
지정된 네임스페이스를 삭제합니다.
이 작업은 되돌릴 수 없으며, 삭제된 네임스페이스와 관련된 모든 데이터는 복구할 수 없게 됩니다.
#### 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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteNamespaceRequest;
import io.gs2.ranking2.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2Ranking2.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_namespace(
ranking2.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
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('ranking2')
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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetServiceVersionRequest;
import io.gs2.ranking2.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2Ranking2.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_service_version(
ranking2.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
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('ranking2')
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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DumpUserDataByUserIdRequest;
import io.gs2.ranking2.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2Ranking2.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.dump_user_data_by_user_id(
ranking2.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
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('ranking2')
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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.ranking2.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2Ranking2.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
ranking2.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('ranking2')
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('ranking2')
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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CleanUserDataByUserIdRequest;
import io.gs2.ranking2.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2Ranking2.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.clean_user_data_by_user_id(
ranking2.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
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('ranking2')
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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.ranking2.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2Ranking2.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
ranking2.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
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('ranking2')
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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.ranking2.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2Ranking2.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
ranking2.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('ranking2')
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('ranking2')
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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.ImportUserDataByUserIdRequest;
import io.gs2.ranking2.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2Ranking2.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.import_user_data_by_user_id(
ranking2.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('ranking2')
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('ranking2')
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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CheckImportUserDataByUserIdRequest;
import io.gs2.ranking2.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2Ranking2.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.check_import_user_data_by_user_id(
ranking2.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('ranking2')
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('ranking2')
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;
```
---
### describeGlobalRankingScores
글로벌 랭킹 스코어 목록 조회
요청한 사용자가 등록한 글로벌 랭킹 스코어의 페이지네이션 목록을 조회합니다. 랭킹 이름으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | | | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<GlobalRankingScore>](#globalrankingscore) | 글로벌 랭킹 스코어 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeGlobalRankingScores(
&ranking2.DescribeGlobalRankingScoresRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeGlobalRankingScoresRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeGlobalRankingScores(
(new DescribeGlobalRankingScoresRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeGlobalRankingScoresRequest;
import io.gs2.ranking2.result.DescribeGlobalRankingScoresResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeGlobalRankingScoresResult result = client.describeGlobalRankingScores(
new DescribeGlobalRankingScoresRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeGlobalRankingScores(
new Gs2.Gs2Ranking2.Request.DescribeGlobalRankingScoresRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeGlobalRankingScores(
new Gs2Ranking2.DescribeGlobalRankingScoresRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_global_ranking_scores(
ranking2.DescribeGlobalRankingScoresRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-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('ranking2')
api_result = client.describe_global_ranking_scores({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-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('ranking2')
api_result_handler = client.describe_global_ranking_scores_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-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;
```
---
### describeGlobalRankingScoresByUserId
사용자 ID를 지정하여 글로벌 랭킹 스코어 목록 조회
지정한 사용자가 등록한 글로벌 랭킹 스코어의 페이지네이션 목록을 조회합니다. 랭킹 이름으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | | | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<GlobalRankingScore>](#globalrankingscore) | 글로벌 랭킹 스코어 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeGlobalRankingScoresByUserId(
&ranking2.DescribeGlobalRankingScoresByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeGlobalRankingScoresByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeGlobalRankingScoresByUserId(
(new DescribeGlobalRankingScoresByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeGlobalRankingScoresByUserIdRequest;
import io.gs2.ranking2.result.DescribeGlobalRankingScoresByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeGlobalRankingScoresByUserIdResult result = client.describeGlobalRankingScoresByUserId(
new DescribeGlobalRankingScoresByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName(null)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeGlobalRankingScoresByUserId(
new Gs2.Gs2Ranking2.Request.DescribeGlobalRankingScoresByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeGlobalRankingScoresByUserId(
new Gs2Ranking2.DescribeGlobalRankingScoresByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName(null)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_global_ranking_scores_by_user_id(
ranking2.DescribeGlobalRankingScoresByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name(None)
.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('ranking2')
api_result = client.describe_global_ranking_scores_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName=nil,
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('ranking2')
api_result_handler = client.describe_global_ranking_scores_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName=nil,
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;
```
---
### putGlobalRankingScore
글로벌 랭킹 스코어 등록
지정한 글로벌 랭킹에 스코어를 등록합니다. 스코어는 랭킹 모델에서 정의된 범위 내에 있어야 합니다. 엔트리 기간 이벤트가 설정된 경우, 활성 기간 중에만 스코어를 등록할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
사용자가 등록한 스코어 값입니다. 랭킹 모델의 minimumValue와 maximumValue로 정의된 범위 내에 있어야 합니다. |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingScore](#globalrankingscore) | 등록한 글로벌 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.PutGlobalRankingScore(
&ranking2.PutGlobalRankingScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
Score: pointy.Int64(100),
Metadata: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\PutGlobalRankingScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->putGlobalRankingScore(
(new PutGlobalRankingScoreRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withScore(100)
->withMetadata(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.PutGlobalRankingScoreRequest;
import io.gs2.ranking2.result.PutGlobalRankingScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
PutGlobalRankingScoreResult result = client.putGlobalRankingScore(
new PutGlobalRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withScore(100L)
.withMetadata(null)
);
GlobalRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.PutGlobalRankingScore(
new Gs2.Gs2Ranking2.Request.PutGlobalRankingScoreRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithScore(100L)
.WithMetadata(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.putGlobalRankingScore(
new Gs2Ranking2.PutGlobalRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withScore(100)
.withMetadata(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.put_global_ranking_score(
ranking2.PutGlobalRankingScoreRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_score(100)
.with_metadata(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.put_global_ranking_score({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
score=100,
metadata=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking2')
api_result_handler = client.put_global_ranking_score_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
score=100,
metadata=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### putGlobalRankingScoreByUserId
사용자 ID를 지정하여 글로벌 랭킹 스코어 등록
지정한 사용자를 대신하여, 지정한 글로벌 랭킹에 스코어를 등록합니다. 스코어는 랭킹 모델에서 정의된 범위 내에 있어야 합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
사용자가 등록한 스코어 값입니다. 랭킹 모델의 minimumValue와 maximumValue로 정의된 범위 내에 있어야 합니다. |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingScore](#globalrankingscore) | 등록한 글로벌 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.PutGlobalRankingScoreByUserId(
&ranking2.PutGlobalRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Score: nil,
Metadata: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\PutGlobalRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->putGlobalRankingScoreByUserId(
(new PutGlobalRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withScore(null)
->withMetadata(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.PutGlobalRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.PutGlobalRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
PutGlobalRankingScoreByUserIdResult result = client.putGlobalRankingScoreByUserId(
new PutGlobalRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withScore(null)
.withMetadata(null)
.withTimeOffsetToken(null)
);
GlobalRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.PutGlobalRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.PutGlobalRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithScore(null)
.WithMetadata(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.putGlobalRankingScoreByUserId(
new Gs2Ranking2.PutGlobalRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withScore(null)
.withMetadata(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.put_global_ranking_score_by_user_id(
ranking2.PutGlobalRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_score(None)
.with_metadata(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.put_global_ranking_score_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
score=nil,
metadata=nil,
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('ranking2')
api_result_handler = client.put_global_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
score=nil,
metadata=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
item = result.item;
```
---
### getGlobalRankingScore
글로벌 랭킹 스코어 조회
지정한 랭킹에 대해 요청한 사용자가 등록한 글로벌 랭킹 스코어를 조회합니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingScore](#globalrankingscore) | 글로벌 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetGlobalRankingScore(
&ranking2.GetGlobalRankingScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
Season: pointy.Int64(0),
}
)
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetGlobalRankingScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getGlobalRankingScore(
(new GetGlobalRankingScoreRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withSeason(0)
);
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetGlobalRankingScoreRequest;
import io.gs2.ranking2.result.GetGlobalRankingScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetGlobalRankingScoreResult result = client.getGlobalRankingScore(
new GetGlobalRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(0L)
);
GlobalRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetGlobalRankingScore(
new Gs2.Gs2Ranking2.Request.GetGlobalRankingScoreRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithSeason(0L),
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getGlobalRankingScore(
new Gs2Ranking2.GetGlobalRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(0)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_global_ranking_score(
ranking2.GetGlobalRankingScoreRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_season(0)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_global_ranking_score({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=0,
})
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('ranking2')
api_result_handler = client.get_global_ranking_score_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=0,
})
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;
```
---
### getGlobalRankingScoreByUserId
사용자 ID를 지정하여 글로벌 랭킹 스코어 조회
지정한 랭킹에 대해 지정한 사용자가 등록한 글로벌 랭킹 스코어를 조회합니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingScore](#globalrankingscore) | 글로벌 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetGlobalRankingScoreByUserId(
&ranking2.GetGlobalRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetGlobalRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getGlobalRankingScoreByUserId(
(new GetGlobalRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetGlobalRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.GetGlobalRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetGlobalRankingScoreByUserIdResult result = client.getGlobalRankingScoreByUserId(
new GetGlobalRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(null)
.withTimeOffsetToken(null)
);
GlobalRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetGlobalRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.GetGlobalRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getGlobalRankingScoreByUserId(
new Gs2Ranking2.GetGlobalRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_global_ranking_score_by_user_id(
ranking2.GetGlobalRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_season(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_global_ranking_score_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=nil,
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('ranking2')
api_result_handler = client.get_global_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=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
item = result.item;
```
---
### deleteGlobalRankingScoreByUserId
사용자 ID를 지정하여 글로벌 랭킹 스코어 삭제
지정한 사용자가 지정한 랭킹 및 시즌에 등록한 글로벌 랭킹 스코어를 삭제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingScore](#globalrankingscore) | 삭제한 글로벌 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteGlobalRankingScoreByUserId(
&ranking2.DeleteGlobalRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteGlobalRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->deleteGlobalRankingScoreByUserId(
(new DeleteGlobalRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteGlobalRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.DeleteGlobalRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DeleteGlobalRankingScoreByUserIdResult result = client.deleteGlobalRankingScoreByUserId(
new DeleteGlobalRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(0L)
.withTimeOffsetToken(null)
);
GlobalRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteGlobalRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.DeleteGlobalRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteGlobalRankingScoreByUserId(
new Gs2Ranking2.DeleteGlobalRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(0)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_global_ranking_score_by_user_id(
ranking2.DeleteGlobalRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_season(0)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.delete_global_ranking_score_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=0,
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('ranking2')
api_result_handler = client.delete_global_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=0,
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;
```
---
### verifyGlobalRankingScore
글로벌 랭킹의 스코어 검증
글로벌 랭킹 스코어를 비교 연산자(less, lessEqual, greater, greaterEqual, equal, notEqual)를 사용하여 지정한 값과 비교 검증합니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| verifyType | 문자열 열거형
enum {
"less",
"lessEqual",
"greater",
"greaterEqual",
"equal",
"notEqual"
}
| | ✓| | | 검증 종류less: 스코어가 지정값 미만일 것 / lessEqual: 스코어가 지정값 이하일 것 / greater: 스코어가 지정값 초과일 것 / greaterEqual: 스코어가 지정값 이상일 것 / equal: 스코어가 지정값과 일치할 것 / notEqual: 스코어가 지정값과 일치하지 않을 것 / |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
사용자가 등록한 스코어 값입니다. 랭킹 모델의 minimumValue와 maximumValue로 정의된 범위 내에 있어야 합니다. |
| multiplyValueSpecifyingQuantity | bool | | | true | | 수량을 지정했을 때, 검증에 사용하는 값도 곱할지 여부 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingScore](#globalrankingscore) | 글로벌 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.VerifyGlobalRankingScore(
&ranking2.VerifyGlobalRankingScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
VerifyType: pointy.String("less"),
Season: nil,
Score: pointy.Int64(100),
MultiplyValueSpecifyingQuantity: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\VerifyGlobalRankingScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->verifyGlobalRankingScore(
(new VerifyGlobalRankingScoreRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withVerifyType("less")
->withSeason(null)
->withScore(100)
->withMultiplyValueSpecifyingQuantity(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.VerifyGlobalRankingScoreRequest;
import io.gs2.ranking2.result.VerifyGlobalRankingScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
VerifyGlobalRankingScoreResult result = client.verifyGlobalRankingScore(
new VerifyGlobalRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100L)
.withMultiplyValueSpecifyingQuantity(null)
);
GlobalRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.VerifyGlobalRankingScore(
new Gs2.Gs2Ranking2.Request.VerifyGlobalRankingScoreRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithVerifyType("less")
.WithSeason(null)
.WithScore(100L)
.WithMultiplyValueSpecifyingQuantity(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.verifyGlobalRankingScore(
new Gs2Ranking2.VerifyGlobalRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100)
.withMultiplyValueSpecifyingQuantity(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.verify_global_ranking_score(
ranking2.VerifyGlobalRankingScoreRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_verify_type('less')
.with_season(None)
.with_score(100)
.with_multiply_value_specifying_quantity(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.verify_global_ranking_score({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=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('ranking2')
api_result_handler = client.verify_global_ranking_score_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=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;
```
---
### verifyGlobalRankingScoreByUserId
사용자 ID를 지정하여 글로벌 랭킹의 스코어 검증
지정한 사용자의 글로벌 랭킹 스코어를 비교 연산자(less, lessEqual, greater, greaterEqual, equal, notEqual)를 사용하여 지정한 값과 비교 검증합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| verifyType | 문자열 열거형
enum {
"less",
"lessEqual",
"greater",
"greaterEqual",
"equal",
"notEqual"
}
| | ✓| | | 검증 종류less: 스코어가 지정값 미만일 것 / lessEqual: 스코어가 지정값 이하일 것 / greater: 스코어가 지정값 초과일 것 / greaterEqual: 스코어가 지정값 이상일 것 / equal: 스코어가 지정값과 일치할 것 / notEqual: 스코어가 지정값과 일치하지 않을 것 / |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
사용자가 등록한 스코어 값입니다. 랭킹 모델의 minimumValue와 maximumValue로 정의된 범위 내에 있어야 합니다. |
| multiplyValueSpecifyingQuantity | bool | | | true | | 수량을 지정했을 때, 검증에 사용하는 값도 곱할지 여부 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingScore](#globalrankingscore) | 글로벌 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.VerifyGlobalRankingScoreByUserId(
&ranking2.VerifyGlobalRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-0001"),
VerifyType: pointy.String("less"),
Season: nil,
Score: pointy.Int64(100),
MultiplyValueSpecifyingQuantity: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\VerifyGlobalRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->verifyGlobalRankingScoreByUserId(
(new VerifyGlobalRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-0001")
->withVerifyType("less")
->withSeason(null)
->withScore(100)
->withMultiplyValueSpecifyingQuantity(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.VerifyGlobalRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.VerifyGlobalRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
VerifyGlobalRankingScoreByUserIdResult result = client.verifyGlobalRankingScoreByUserId(
new VerifyGlobalRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100L)
.withMultiplyValueSpecifyingQuantity(null)
.withTimeOffsetToken(null)
);
GlobalRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.VerifyGlobalRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.VerifyGlobalRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-0001")
.WithVerifyType("less")
.WithSeason(null)
.WithScore(100L)
.WithMultiplyValueSpecifyingQuantity(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.verifyGlobalRankingScoreByUserId(
new Gs2Ranking2.VerifyGlobalRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100)
.withMultiplyValueSpecifyingQuantity(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.verify_global_ranking_score_by_user_id(
ranking2.VerifyGlobalRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-0001')
.with_verify_type('less')
.with_season(None)
.with_score(100)
.with_multiply_value_specifying_quantity(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.verify_global_ranking_score_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=nil,
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('ranking2')
api_result_handler = client.verify_global_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=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
item = result.item;
```
---
### describeGlobalRankingReceivedRewards
글로벌 랭킹 보상 수령 이력 목록 취득
요청한 사용자의 글로벌 랭킹 보상 수령 이력의 페이지네이션이 포함된 목록을 취득합니다. 랭킹 이름과 시즌으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | | | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<GlobalRankingReceivedReward>](#globalrankingreceivedreward) | 글로벌 랭킹 보상 수령 이력 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeGlobalRankingReceivedRewards(
&ranking2.DescribeGlobalRankingReceivedRewardsRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeGlobalRankingReceivedRewardsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeGlobalRankingReceivedRewards(
(new DescribeGlobalRankingReceivedRewardsRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeGlobalRankingReceivedRewardsRequest;
import io.gs2.ranking2.result.DescribeGlobalRankingReceivedRewardsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeGlobalRankingReceivedRewardsResult result = client.describeGlobalRankingReceivedRewards(
new DescribeGlobalRankingReceivedRewardsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withSeason(0L)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeGlobalRankingReceivedRewards(
new Gs2.Gs2Ranking2.Request.DescribeGlobalRankingReceivedRewardsRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeGlobalRankingReceivedRewards(
new Gs2Ranking2.DescribeGlobalRankingReceivedRewardsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withSeason(0)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_global_ranking_received_rewards(
ranking2.DescribeGlobalRankingReceivedRewardsRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_season(0)
.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('ranking2')
api_result = client.describe_global_ranking_received_rewards({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
season=0,
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('ranking2')
api_result_handler = client.describe_global_ranking_received_rewards_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
season=0,
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;
```
---
### describeGlobalRankingReceivedRewardsByUserId
사용자 ID를 지정하여 글로벌 랭킹 보상 수령 이력 목록 취득
지정한 사용자의 글로벌 랭킹 보상 수령 이력의 페이지네이션이 포함된 목록을 취득합니다. 랭킹 이름과 시즌으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | | | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<GlobalRankingReceivedReward>](#globalrankingreceivedreward) | 글로벌 랭킹 보상 수령 이력 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeGlobalRankingReceivedRewardsByUserId(
&ranking2.DescribeGlobalRankingReceivedRewardsByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeGlobalRankingReceivedRewardsByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeGlobalRankingReceivedRewardsByUserId(
(new DescribeGlobalRankingReceivedRewardsByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeGlobalRankingReceivedRewardsByUserIdRequest;
import io.gs2.ranking2.result.DescribeGlobalRankingReceivedRewardsByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeGlobalRankingReceivedRewardsByUserIdResult result = client.describeGlobalRankingReceivedRewardsByUserId(
new DescribeGlobalRankingReceivedRewardsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withSeason(null)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeGlobalRankingReceivedRewardsByUserId(
new Gs2.Gs2Ranking2.Request.DescribeGlobalRankingReceivedRewardsByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeGlobalRankingReceivedRewardsByUserId(
new Gs2Ranking2.DescribeGlobalRankingReceivedRewardsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withSeason(null)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_global_ranking_received_rewards_by_user_id(
ranking2.DescribeGlobalRankingReceivedRewardsByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-0001')
.with_season(None)
.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('ranking2')
api_result = client.describe_global_ranking_received_rewards_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
season=nil,
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('ranking2')
api_result_handler = client.describe_global_ranking_received_rewards_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
season=nil,
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;
```
---
### createGlobalRankingReceivedReward
글로벌 랭킹 보상 수령 이력 기록
지정한 글로벌 랭킹의 보상 수령 이력을 기록합니다. 실제로 보상을 수령하기 전에 이 기록이 필요합니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingReceivedReward](#globalrankingreceivedreward) | 글로벌 랭킹 보상 수령 이력 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CreateGlobalRankingReceivedReward(
&ranking2.CreateGlobalRankingReceivedRewardRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
Season: pointy.Int64(0),
}
)
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CreateGlobalRankingReceivedRewardRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->createGlobalRankingReceivedReward(
(new CreateGlobalRankingReceivedRewardRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withSeason(0)
);
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CreateGlobalRankingReceivedRewardRequest;
import io.gs2.ranking2.result.CreateGlobalRankingReceivedRewardResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
CreateGlobalRankingReceivedRewardResult result = client.createGlobalRankingReceivedReward(
new CreateGlobalRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(0L)
);
GlobalRankingReceivedReward 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateGlobalRankingReceivedReward(
new Gs2.Gs2Ranking2.Request.CreateGlobalRankingReceivedRewardRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithSeason(0L),
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.createGlobalRankingReceivedReward(
new Gs2Ranking2.CreateGlobalRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(0)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.create_global_ranking_received_reward(
ranking2.CreateGlobalRankingReceivedRewardRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_season(0)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.create_global_ranking_received_reward({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=0,
})
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('ranking2')
api_result_handler = client.create_global_ranking_received_reward_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=0,
})
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;
```
---
### createGlobalRankingReceivedRewardByUserId
사용자 ID를 지정하여 글로벌 랭킹 보상 수령 이력 기록
지정한 사용자를 대신하여, 지정한 글로벌 랭킹의 보상 수령 이력을 기록합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingReceivedReward](#globalrankingreceivedreward) | 글로벌 랭킹 보상 수령 이력 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CreateGlobalRankingReceivedRewardByUserId(
&ranking2.CreateGlobalRankingReceivedRewardByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CreateGlobalRankingReceivedRewardByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->createGlobalRankingReceivedRewardByUserId(
(new CreateGlobalRankingReceivedRewardByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CreateGlobalRankingReceivedRewardByUserIdRequest;
import io.gs2.ranking2.result.CreateGlobalRankingReceivedRewardByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
CreateGlobalRankingReceivedRewardByUserIdResult result = client.createGlobalRankingReceivedRewardByUserId(
new CreateGlobalRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(0L)
.withTimeOffsetToken(null)
);
GlobalRankingReceivedReward 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateGlobalRankingReceivedRewardByUserId(
new Gs2.Gs2Ranking2.Request.CreateGlobalRankingReceivedRewardByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.createGlobalRankingReceivedRewardByUserId(
new Gs2Ranking2.CreateGlobalRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(0)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.create_global_ranking_received_reward_by_user_id(
ranking2.CreateGlobalRankingReceivedRewardByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_season(0)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.create_global_ranking_received_reward_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=0,
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('ranking2')
api_result_handler = client.create_global_ranking_received_reward_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=0,
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;
```
---
### receiveGlobalRankingReceivedReward
글로벌 랭킹 보상 수령
지정한 글로벌 랭킹과 시즌의 랭킹 보상을 수령합니다. 보상은 사용자의 랭킹 순위와 랭킹 모델의 보상 설정에 따라 결정됩니다. 보상 아이템을 부여하기 위한 트랜잭션이 발행됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| config | [List<Config>](#config) | | | [] | 0 ~ 32 items | 트랜잭션 변수에 적용할 설정값 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingModel](#globalrankingmodel) | 글로벌 랭킹 모델 |
| acquireActions | [List<AcquireAction>](#acquireaction) | 보상 수령 시 실행되는 입수 액션 목록 |
| 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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.ReceiveGlobalRankingReceivedReward(
&ranking2.ReceiveGlobalRankingReceivedRewardRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
Season: pointy.Int64(0),
Config: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
acquireActions := result.AcquireActions
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\ReceiveGlobalRankingReceivedRewardRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->receiveGlobalRankingReceivedReward(
(new ReceiveGlobalRankingReceivedRewardRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withSeason(0)
->withConfig(null)
);
$item = $result->getItem();
$acquireActions = $result->getAcquireActions();
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.ReceiveGlobalRankingReceivedRewardRequest;
import io.gs2.ranking2.result.ReceiveGlobalRankingReceivedRewardResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
ReceiveGlobalRankingReceivedRewardResult result = client.receiveGlobalRankingReceivedReward(
new ReceiveGlobalRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withSeason(0L)
.withConfig(null)
);
GlobalRankingModel item = result.getItem();
List acquireActions = result.getAcquireActions();
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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.ReceiveGlobalRankingReceivedReward(
new Gs2.Gs2Ranking2.Request.ReceiveGlobalRankingReceivedRewardRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithSeason(0L)
.WithConfig(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var acquireActions = result.AcquireActions;
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.receiveGlobalRankingReceivedReward(
new Gs2Ranking2.ReceiveGlobalRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withSeason(0)
.withConfig(null)
);
const item = result.getItem();
const acquireActions = result.getAcquireActions();
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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.receive_global_ranking_received_reward(
ranking2.ReceiveGlobalRankingReceivedRewardRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_season(0)
.with_config(None)
)
item = result.item
acquire_actions = result.acquire_actions
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('ranking2')
api_result = client.receive_global_ranking_received_reward({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
season=0,
config=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
acquireActions = result.acquireActions;
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('ranking2')
api_result_handler = client.receive_global_ranking_received_reward_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
season=0,
config=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
acquireActions = result.acquireActions;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### receiveGlobalRankingReceivedRewardByUserId
사용자 ID를 지정하여 글로벌 랭킹 보상 수령
지정한 사용자를 대신하여, 지정한 글로벌 랭킹과 시즌의 랭킹 보상을 수령합니다. 보상 아이템을 부여하기 위한 트랜잭션이 발행됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| config | [List<Config>](#config) | | | [] | 0 ~ 32 items | 트랜잭션 변수에 적용할 설정값 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingModel](#globalrankingmodel) | 글로벌 랭킹 모델 |
| acquireActions | [List<AcquireAction>](#acquireaction) | 보상 수령 시 실행되는 입수 액션 목록 |
| 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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.ReceiveGlobalRankingReceivedRewardByUserId(
&ranking2.ReceiveGlobalRankingReceivedRewardByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-0001"),
Season: pointy.Int64(0),
Config: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
acquireActions := result.AcquireActions
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\ReceiveGlobalRankingReceivedRewardByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->receiveGlobalRankingReceivedRewardByUserId(
(new ReceiveGlobalRankingReceivedRewardByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-0001")
->withSeason(0)
->withConfig(null)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$acquireActions = $result->getAcquireActions();
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.ReceiveGlobalRankingReceivedRewardByUserIdRequest;
import io.gs2.ranking2.result.ReceiveGlobalRankingReceivedRewardByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
ReceiveGlobalRankingReceivedRewardByUserIdResult result = client.receiveGlobalRankingReceivedRewardByUserId(
new ReceiveGlobalRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withSeason(0L)
.withConfig(null)
.withTimeOffsetToken(null)
);
GlobalRankingModel item = result.getItem();
List acquireActions = result.getAcquireActions();
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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.ReceiveGlobalRankingReceivedRewardByUserId(
new Gs2.Gs2Ranking2.Request.ReceiveGlobalRankingReceivedRewardByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-0001")
.WithSeason(0L)
.WithConfig(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var acquireActions = result.AcquireActions;
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.receiveGlobalRankingReceivedRewardByUserId(
new Gs2Ranking2.ReceiveGlobalRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withSeason(0)
.withConfig(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
const acquireActions = result.getAcquireActions();
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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.receive_global_ranking_received_reward_by_user_id(
ranking2.ReceiveGlobalRankingReceivedRewardByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-0001')
.with_season(0)
.with_config(None)
.with_time_offset_token(None)
)
item = result.item
acquire_actions = result.acquire_actions
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('ranking2')
api_result = client.receive_global_ranking_received_reward_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
season=0,
config=nil,
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;
acquireActions = result.acquireActions;
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('ranking2')
api_result_handler = client.receive_global_ranking_received_reward_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
season=0,
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
item = result.item;
acquireActions = result.acquireActions;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### getGlobalRankingReceivedReward
글로벌 랭킹 보상 수령 이력 취득
지정한 글로벌 랭킹의 보상 수령 이력을 취득합니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingReceivedReward](#globalrankingreceivedreward) | 글로벌 랭킹 보상 수령 이력 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetGlobalRankingReceivedReward(
&ranking2.GetGlobalRankingReceivedRewardRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
Season: pointy.Int64(0),
}
)
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetGlobalRankingReceivedRewardRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getGlobalRankingReceivedReward(
(new GetGlobalRankingReceivedRewardRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withSeason(0)
);
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetGlobalRankingReceivedRewardRequest;
import io.gs2.ranking2.result.GetGlobalRankingReceivedRewardResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetGlobalRankingReceivedRewardResult result = client.getGlobalRankingReceivedReward(
new GetGlobalRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(0L)
);
GlobalRankingReceivedReward 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetGlobalRankingReceivedReward(
new Gs2.Gs2Ranking2.Request.GetGlobalRankingReceivedRewardRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithSeason(0L),
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getGlobalRankingReceivedReward(
new Gs2Ranking2.GetGlobalRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(0)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_global_ranking_received_reward(
ranking2.GetGlobalRankingReceivedRewardRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_season(0)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_global_ranking_received_reward({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=0,
})
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('ranking2')
api_result_handler = client.get_global_ranking_received_reward_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=0,
})
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;
```
---
### getGlobalRankingReceivedRewardByUserId
사용자 ID를 지정하여 글로벌 랭킹 보상 수령 이력 취득
지정한 사용자의 지정한 글로벌 랭킹의 보상 수령 이력을 취득합니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingReceivedReward](#globalrankingreceivedreward) | 글로벌 랭킹 보상 수령 이력 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetGlobalRankingReceivedRewardByUserId(
&ranking2.GetGlobalRankingReceivedRewardByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetGlobalRankingReceivedRewardByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getGlobalRankingReceivedRewardByUserId(
(new GetGlobalRankingReceivedRewardByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetGlobalRankingReceivedRewardByUserIdRequest;
import io.gs2.ranking2.result.GetGlobalRankingReceivedRewardByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetGlobalRankingReceivedRewardByUserIdResult result = client.getGlobalRankingReceivedRewardByUserId(
new GetGlobalRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(0L)
.withTimeOffsetToken(null)
);
GlobalRankingReceivedReward 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetGlobalRankingReceivedRewardByUserId(
new Gs2.Gs2Ranking2.Request.GetGlobalRankingReceivedRewardByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getGlobalRankingReceivedRewardByUserId(
new Gs2Ranking2.GetGlobalRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(0)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_global_ranking_received_reward_by_user_id(
ranking2.GetGlobalRankingReceivedRewardByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_season(0)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_global_ranking_received_reward_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=0,
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('ranking2')
api_result_handler = client.get_global_ranking_received_reward_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=0,
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;
```
---
### deleteGlobalRankingReceivedRewardByUserId
사용자 ID를 지정하여 글로벌 랭킹 보상 수령 이력 삭제
지정한 사용자의 지정한 랭킹 및 시즌의 글로벌 랭킹 보상 수령 이력을 삭제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | ✓| | 0 ~ 9223372036854775805 | 시즌
GS2-Schedule 이벤트의 반복 횟수에 대응하는 시즌 번호입니다. 새로운 랭킹 기간마다 증가합니다. |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingReceivedReward](#globalrankingreceivedreward) | 삭제한 글로벌 랭킹 보상 수령 이력 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteGlobalRankingReceivedRewardByUserId(
&ranking2.DeleteGlobalRankingReceivedRewardByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteGlobalRankingReceivedRewardByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->deleteGlobalRankingReceivedRewardByUserId(
(new DeleteGlobalRankingReceivedRewardByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteGlobalRankingReceivedRewardByUserIdRequest;
import io.gs2.ranking2.result.DeleteGlobalRankingReceivedRewardByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DeleteGlobalRankingReceivedRewardByUserIdResult result = client.deleteGlobalRankingReceivedRewardByUserId(
new DeleteGlobalRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(0L)
.withTimeOffsetToken(null)
);
GlobalRankingReceivedReward 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteGlobalRankingReceivedRewardByUserId(
new Gs2.Gs2Ranking2.Request.DeleteGlobalRankingReceivedRewardByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteGlobalRankingReceivedRewardByUserId(
new Gs2Ranking2.DeleteGlobalRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(0)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_global_ranking_received_reward_by_user_id(
ranking2.DeleteGlobalRankingReceivedRewardByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_season(0)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.delete_global_ranking_received_reward_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=0,
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('ranking2')
api_result_handler = client.delete_global_ranking_received_reward_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=0,
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;
```
---
### describeGlobalRankings
글로벌 랭킹 목록 조회
지정한 랭킹의 글로벌 랭킹 데이터의 페이지네이션 지원 목록을 조회합니다. 랭킹 데이터에는 순위, 스코어, 사용자 정보가 포함됩니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<GlobalRankingData>](#globalrankingdata) | 글로벌 랭킹 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeGlobalRankings(
&ranking2.DescribeGlobalRankingsRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
Season: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeGlobalRankingsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeGlobalRankings(
(new DescribeGlobalRankingsRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withSeason(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeGlobalRankingsRequest;
import io.gs2.ranking2.result.DescribeGlobalRankingsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeGlobalRankingsResult result = client.describeGlobalRankings(
new DescribeGlobalRankingsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withSeason(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeGlobalRankings(
new Gs2.Gs2Ranking2.Request.DescribeGlobalRankingsRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithSeason(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeGlobalRankings(
new Gs2Ranking2.DescribeGlobalRankingsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withSeason(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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_global_rankings(
ranking2.DescribeGlobalRankingsRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_season(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('ranking2')
api_result = client.describe_global_rankings({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
season=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('ranking2')
api_result_handler = client.describe_global_rankings_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
season=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;
```
---
### describeGlobalRankingsByUserId
사용자 ID를 지정하여 글로벌 랭킹 목록 조회
지정한 사용자를 대신하여, 지정한 랭킹의 글로벌 랭킹 데이터의 페이지네이션 지원 목록을 조회합니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<GlobalRankingData>](#globalrankingdata) | 글로벌 랭킹 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeGlobalRankingsByUserId(
&ranking2.DescribeGlobalRankingsByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeGlobalRankingsByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeGlobalRankingsByUserId(
(new DescribeGlobalRankingsByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeGlobalRankingsByUserIdRequest;
import io.gs2.ranking2.result.DescribeGlobalRankingsByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeGlobalRankingsByUserIdResult result = client.describeGlobalRankingsByUserId(
new DescribeGlobalRankingsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withSeason(null)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeGlobalRankingsByUserId(
new Gs2.Gs2Ranking2.Request.DescribeGlobalRankingsByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeGlobalRankingsByUserId(
new Gs2Ranking2.DescribeGlobalRankingsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withSeason(null)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_global_rankings_by_user_id(
ranking2.DescribeGlobalRankingsByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-0001')
.with_season(None)
.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('ranking2')
api_result = client.describe_global_rankings_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
season=nil,
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('ranking2')
api_result_handler = client.describe_global_rankings_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
season=nil,
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;
```
---
### getGlobalRanking
글로벌 랭킹 조회
지정한 글로벌 랭킹에서 요청한 사용자의 순위와 스코어를 조회합니다. 랭킹 데이터는 등록된 스코어로부터 계산됩니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingData](#globalrankingdata) | 글로벌 랭킹 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetGlobalRanking(
&ranking2.GetGlobalRankingRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
Season: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetGlobalRankingRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getGlobalRanking(
(new GetGlobalRankingRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withSeason(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetGlobalRankingRequest;
import io.gs2.ranking2.result.GetGlobalRankingResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetGlobalRankingResult result = client.getGlobalRanking(
new GetGlobalRankingRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(null)
);
GlobalRankingData 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetGlobalRanking(
new Gs2.Gs2Ranking2.Request.GetGlobalRankingRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithSeason(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getGlobalRanking(
new Gs2Ranking2.GetGlobalRankingRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_global_ranking(
ranking2.GetGlobalRankingRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_season(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_global_ranking({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=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('ranking2')
api_result_handler = client.get_global_ranking_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=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;
```
---
### getGlobalRankingByUserId
사용자 ID를 지정하여 글로벌 랭킹 조회
지정한 글로벌 랭킹에서 지정한 사용자의 순위와 스코어를 조회합니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingData](#globalrankingdata) | 글로벌 랭킹 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetGlobalRankingByUserId(
&ranking2.GetGlobalRankingByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetGlobalRankingByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getGlobalRankingByUserId(
(new GetGlobalRankingByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetGlobalRankingByUserIdRequest;
import io.gs2.ranking2.result.GetGlobalRankingByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetGlobalRankingByUserIdResult result = client.getGlobalRankingByUserId(
new GetGlobalRankingByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(null)
.withTimeOffsetToken(null)
);
GlobalRankingData 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetGlobalRankingByUserId(
new Gs2.Gs2Ranking2.Request.GetGlobalRankingByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getGlobalRankingByUserId(
new Gs2Ranking2.GetGlobalRankingByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_global_ranking_by_user_id(
ranking2.GetGlobalRankingByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_season(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_global_ranking_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=nil,
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('ranking2')
api_result_handler = client.get_global_ranking_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=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
item = result.item;
```
---
### describeClusterRankingScores
클러스터 랭킹 스코어 목록 취득
요청한 사용자가 등록한 클러스터 랭킹 스코어의 페이지네이션이 포함된 목록을 취득합니다. 랭킹 이름, 클러스터 이름, 시즌으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | | | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | | | ~ 1024자 | 클러스터 이름
이 스코어가 속한 클러스터(길드, 개더링, 또는 임의의 그룹)의 이름입니다. 클러스터 타입 설정에 따라 사용자의 소속이 검증됩니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<ClusterRankingScore>](#clusterrankingscore) | 클러스터 랭킹 스코어 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeClusterRankingScores(
&ranking2.DescribeClusterRankingScoresRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeClusterRankingScoresRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeClusterRankingScores(
(new DescribeClusterRankingScoresRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeClusterRankingScoresRequest;
import io.gs2.ranking2.result.DescribeClusterRankingScoresResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeClusterRankingScoresResult result = client.describeClusterRankingScores(
new DescribeClusterRankingScoresRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(0L)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeClusterRankingScores(
new Gs2.Gs2Ranking2.Request.DescribeClusterRankingScoresRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeClusterRankingScores(
new Gs2Ranking2.DescribeClusterRankingScoresRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(0)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_cluster_ranking_scores(
ranking2.DescribeClusterRankingScoresRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_season(0)
.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('ranking2')
api_result = client.describe_cluster_ranking_scores({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=0,
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('ranking2')
api_result_handler = client.describe_cluster_ranking_scores_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=0,
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;
```
---
### describeClusterRankingScoresByUserId
사용자 ID를 지정하여 클러스터 랭킹 스코어 목록 취득
지정한 사용자가 등록한 클러스터 랭킹 스코어의 페이지네이션이 포함된 목록을 취득합니다. 랭킹 이름, 클러스터 이름, 시즌으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | | | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | | | ~ 1024자 | 클러스터 이름
이 스코어가 속한 클러스터(길드, 개더링, 또는 임의의 그룹)의 이름입니다. 클러스터 타입 설정에 따라 사용자의 소속이 검증됩니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<ClusterRankingScore>](#clusterrankingscore) | 클러스터 랭킹 스코어 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeClusterRankingScoresByUserId(
&ranking2.DescribeClusterRankingScoresByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: nil,
ClusterName: pointy.String("cluster-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeClusterRankingScoresByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeClusterRankingScoresByUserId(
(new DescribeClusterRankingScoresByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName(null)
->withClusterName("cluster-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeClusterRankingScoresByUserIdRequest;
import io.gs2.ranking2.result.DescribeClusterRankingScoresByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeClusterRankingScoresByUserIdResult result = client.describeClusterRankingScoresByUserId(
new DescribeClusterRankingScoresByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName(null)
.withClusterName("cluster-0001")
.withSeason(null)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeClusterRankingScoresByUserId(
new Gs2.Gs2Ranking2.Request.DescribeClusterRankingScoresByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName(null)
.WithClusterName("cluster-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeClusterRankingScoresByUserId(
new Gs2Ranking2.DescribeClusterRankingScoresByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName(null)
.withClusterName("cluster-0001")
.withSeason(null)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_cluster_ranking_scores_by_user_id(
ranking2.DescribeClusterRankingScoresByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name(None)
.with_cluster_name('cluster-0001')
.with_season(None)
.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('ranking2')
api_result = client.describe_cluster_ranking_scores_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName=nil,
clusterName="cluster-0001",
season=nil,
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('ranking2')
api_result_handler = client.describe_cluster_ranking_scores_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName=nil,
clusterName="cluster-0001",
season=nil,
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;
```
---
### putClusterRankingScore
클러스터 랭킹 스코어 등록
지정한 클러스터 랭킹에 스코어를 등록합니다. 사용자는 지정한 클러스터(길드 또는 매치메이킹 게더링)에 소속되어 있어야 합니다. 스코어는 랭킹 모델에서 정의된 범위 내에 있어야 합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 스코어가 속한 클러스터(길드, 개더링, 또는 임의의 그룹)의 이름입니다. 클러스터 타입 설정에 따라 사용자의 소속이 검증됩니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
이 클러스터 내에서 사용자가 등록한 스코어 값입니다. |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingScore](#clusterrankingscore) | 등록한 클러스터 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.PutClusterRankingScore(
&ranking2.PutClusterRankingScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
AccessToken: pointy.String("accessToken-0001"),
Score: pointy.Int64(100),
Metadata: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\PutClusterRankingScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->putClusterRankingScore(
(new PutClusterRankingScoreRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withAccessToken("accessToken-0001")
->withScore(100)
->withMetadata(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.PutClusterRankingScoreRequest;
import io.gs2.ranking2.result.PutClusterRankingScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
PutClusterRankingScoreResult result = client.putClusterRankingScore(
new PutClusterRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withAccessToken("accessToken-0001")
.withScore(100L)
.withMetadata(null)
);
ClusterRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.PutClusterRankingScore(
new Gs2.Gs2Ranking2.Request.PutClusterRankingScoreRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithAccessToken("accessToken-0001")
.WithScore(100L)
.WithMetadata(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.putClusterRankingScore(
new Gs2Ranking2.PutClusterRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withAccessToken("accessToken-0001")
.withScore(100)
.withMetadata(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.put_cluster_ranking_score(
ranking2.PutClusterRankingScoreRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_access_token('accessToken-0001')
.with_score(100)
.with_metadata(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.put_cluster_ranking_score({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
accessToken="accessToken-0001",
score=100,
metadata=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking2')
api_result_handler = client.put_cluster_ranking_score_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
accessToken="accessToken-0001",
score=100,
metadata=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### putClusterRankingScoreByUserId
사용자 ID를 지정하여 클러스터 랭킹 스코어 등록
지정한 사용자를 대신하여, 지정한 클러스터 랭킹에 스코어를 등록합니다. 사용자는 지정한 클러스터에 소속되어 있어야 합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 스코어가 속한 클러스터(길드, 개더링, 또는 임의의 그룹)의 이름입니다. 클러스터 타입 설정에 따라 사용자의 소속이 검증됩니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
이 클러스터 내에서 사용자가 등록한 스코어 값입니다. |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingScore](#clusterrankingscore) | 등록한 클러스터 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.PutClusterRankingScoreByUserId(
&ranking2.PutClusterRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
UserId: pointy.String("user-0001"),
Score: nil,
Metadata: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\PutClusterRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->putClusterRankingScoreByUserId(
(new PutClusterRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withUserId("user-0001")
->withScore(null)
->withMetadata(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.PutClusterRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.PutClusterRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
PutClusterRankingScoreByUserIdResult result = client.putClusterRankingScoreByUserId(
new PutClusterRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withScore(null)
.withMetadata(null)
.withTimeOffsetToken(null)
);
ClusterRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.PutClusterRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.PutClusterRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithUserId("user-0001")
.WithScore(null)
.WithMetadata(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.putClusterRankingScoreByUserId(
new Gs2Ranking2.PutClusterRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withScore(null)
.withMetadata(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.put_cluster_ranking_score_by_user_id(
ranking2.PutClusterRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_user_id('user-0001')
.with_score(None)
.with_metadata(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.put_cluster_ranking_score_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
score=nil,
metadata=nil,
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('ranking2')
api_result_handler = client.put_cluster_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
score=nil,
metadata=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
item = result.item;
```
---
### getClusterRankingScore
클러스터 랭킹 스코어 취득
지정한 랭킹 및 클러스터에 대해 요청한 사용자가 등록한 클러스터 랭킹 스코어를 취득합니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 스코어가 속한 클러스터(길드, 개더링, 또는 임의의 그룹)의 이름입니다. 클러스터 타입 설정에 따라 사용자의 소속이 검증됩니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingScore](#clusterrankingscore) | 클러스터 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetClusterRankingScore(
&ranking2.GetClusterRankingScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
AccessToken: pointy.String("accessToken-0001"),
Season: pointy.Int64(0),
}
)
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetClusterRankingScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getClusterRankingScore(
(new GetClusterRankingScoreRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withAccessToken("accessToken-0001")
->withSeason(0)
);
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetClusterRankingScoreRequest;
import io.gs2.ranking2.result.GetClusterRankingScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetClusterRankingScoreResult result = client.getClusterRankingScore(
new GetClusterRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withAccessToken("accessToken-0001")
.withSeason(0L)
);
ClusterRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetClusterRankingScore(
new Gs2.Gs2Ranking2.Request.GetClusterRankingScoreRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithAccessToken("accessToken-0001")
.WithSeason(0L),
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getClusterRankingScore(
new Gs2Ranking2.GetClusterRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withAccessToken("accessToken-0001")
.withSeason(0)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_cluster_ranking_score(
ranking2.GetClusterRankingScoreRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_access_token('accessToken-0001')
.with_season(0)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_cluster_ranking_score({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
accessToken="accessToken-0001",
season=0,
})
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('ranking2')
api_result_handler = client.get_cluster_ranking_score_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
accessToken="accessToken-0001",
season=0,
})
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;
```
---
### getClusterRankingScoreByUserId
사용자 ID를 지정하여 클러스터 랭킹 스코어 취득
지정한 랭킹 및 클러스터에 대해 지정한 사용자가 등록한 클러스터 랭킹 스코어를 취득합니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 스코어가 속한 클러스터(길드, 개더링, 또는 임의의 그룹)의 이름입니다. 클러스터 타입 설정에 따라 사용자의 소속이 검증됩니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingScore](#clusterrankingscore) | 클러스터 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetClusterRankingScoreByUserId(
&ranking2.GetClusterRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
UserId: pointy.String("user-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetClusterRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getClusterRankingScoreByUserId(
(new GetClusterRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withUserId("user-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetClusterRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.GetClusterRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetClusterRankingScoreByUserIdResult result = client.getClusterRankingScoreByUserId(
new GetClusterRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(null)
.withTimeOffsetToken(null)
);
ClusterRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetClusterRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.GetClusterRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithUserId("user-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getClusterRankingScoreByUserId(
new Gs2Ranking2.GetClusterRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_cluster_ranking_score_by_user_id(
ranking2.GetClusterRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_user_id('user-0001')
.with_season(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_cluster_ranking_score_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=nil,
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('ranking2')
api_result_handler = client.get_cluster_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=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
item = result.item;
```
---
### deleteClusterRankingScoreByUserId
사용자 ID를 지정하여 클러스터 랭킹 스코어 삭제
지정한 사용자가 지정한 랭킹, 클러스터, 시즌에 등록한 클러스터 랭킹 스코어를 삭제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 스코어가 속한 클러스터(길드, 개더링, 또는 임의의 그룹)의 이름입니다. 클러스터 타입 설정에 따라 사용자의 소속이 검증됩니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingScore](#clusterrankingscore) | 삭제한 클러스터 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteClusterRankingScoreByUserId(
&ranking2.DeleteClusterRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
UserId: pointy.String("user-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteClusterRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->deleteClusterRankingScoreByUserId(
(new DeleteClusterRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withUserId("user-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteClusterRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.DeleteClusterRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DeleteClusterRankingScoreByUserIdResult result = client.deleteClusterRankingScoreByUserId(
new DeleteClusterRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(0L)
.withTimeOffsetToken(null)
);
ClusterRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteClusterRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.DeleteClusterRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithUserId("user-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteClusterRankingScoreByUserId(
new Gs2Ranking2.DeleteClusterRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(0)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_cluster_ranking_score_by_user_id(
ranking2.DeleteClusterRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_user_id('user-0001')
.with_season(0)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.delete_cluster_ranking_score_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=0,
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('ranking2')
api_result_handler = client.delete_cluster_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=0,
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;
```
---
### verifyClusterRankingScore
클러스터 랭킹의 스코어 검증
클러스터 랭킹 스코어를 비교 연산자(less, lessEqual, greater, greaterEqual, equal, notEqual)를 사용하여 지정한 값과 비교 검증합니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 스코어가 속한 클러스터(길드, 개더링, 또는 임의의 그룹)의 이름입니다. 클러스터 타입 설정에 따라 사용자의 소속이 검증됩니다. |
| verifyType | 문자열 열거형
enum {
"less",
"lessEqual",
"greater",
"greaterEqual",
"equal",
"notEqual"
}
| | ✓| | | 검증 종류less: 스코어가 지정값 미만일 것 / lessEqual: 스코어가 지정값 이하일 것 / greater: 스코어가 지정값 초과일 것 / greaterEqual: 스코어가 지정값 이상일 것 / equal: 스코어가 지정값과 일치할 것 / notEqual: 스코어가 지정값과 일치하지 않을 것 / |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
이 클러스터 내에서 사용자가 등록한 스코어 값입니다. |
| multiplyValueSpecifyingQuantity | bool | | | true | | 수량을 지정했을 때, 검증에 사용하는 값도 곱할지 여부 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingScore](#clusterrankingscore) | 클러스터 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.VerifyClusterRankingScore(
&ranking2.VerifyClusterRankingScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
VerifyType: pointy.String("less"),
Season: nil,
Score: pointy.Int64(100),
MultiplyValueSpecifyingQuantity: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\VerifyClusterRankingScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->verifyClusterRankingScore(
(new VerifyClusterRankingScoreRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withVerifyType("less")
->withSeason(null)
->withScore(100)
->withMultiplyValueSpecifyingQuantity(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.VerifyClusterRankingScoreRequest;
import io.gs2.ranking2.result.VerifyClusterRankingScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
VerifyClusterRankingScoreResult result = client.verifyClusterRankingScore(
new VerifyClusterRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100L)
.withMultiplyValueSpecifyingQuantity(null)
);
ClusterRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.VerifyClusterRankingScore(
new Gs2.Gs2Ranking2.Request.VerifyClusterRankingScoreRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithVerifyType("less")
.WithSeason(null)
.WithScore(100L)
.WithMultiplyValueSpecifyingQuantity(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.verifyClusterRankingScore(
new Gs2Ranking2.VerifyClusterRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100)
.withMultiplyValueSpecifyingQuantity(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.verify_cluster_ranking_score(
ranking2.VerifyClusterRankingScoreRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_verify_type('less')
.with_season(None)
.with_score(100)
.with_multiply_value_specifying_quantity(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.verify_cluster_ranking_score({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=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('ranking2')
api_result_handler = client.verify_cluster_ranking_score_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=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;
```
---
### verifyClusterRankingScoreByUserId
사용자 ID를 지정하여 클러스터 랭킹의 스코어 검증
지정한 사용자의 클러스터 랭킹 스코어를 비교 연산자(less, lessEqual, greater, greaterEqual, equal, notEqual)를 사용하여 지정한 값과 비교 검증합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 스코어가 속한 클러스터(길드, 개더링, 또는 임의의 그룹)의 이름입니다. 클러스터 타입 설정에 따라 사용자의 소속이 검증됩니다. |
| verifyType | 문자열 열거형
enum {
"less",
"lessEqual",
"greater",
"greaterEqual",
"equal",
"notEqual"
}
| | ✓| | | 검증 종류less: 스코어가 지정값 미만일 것 / lessEqual: 스코어가 지정값 이하일 것 / greater: 스코어가 지정값 초과일 것 / greaterEqual: 스코어가 지정값 이상일 것 / equal: 스코어가 지정값과 일치할 것 / notEqual: 스코어가 지정값과 일치하지 않을 것 / |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
이 클러스터 내에서 사용자가 등록한 스코어 값입니다. |
| multiplyValueSpecifyingQuantity | bool | | | true | | 수량을 지정했을 때, 검증에 사용하는 값도 곱할지 여부 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingScore](#clusterrankingscore) | 클러스터 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.VerifyClusterRankingScoreByUserId(
&ranking2.VerifyClusterRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
VerifyType: pointy.String("less"),
Season: nil,
Score: pointy.Int64(100),
MultiplyValueSpecifyingQuantity: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\VerifyClusterRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->verifyClusterRankingScoreByUserId(
(new VerifyClusterRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withVerifyType("less")
->withSeason(null)
->withScore(100)
->withMultiplyValueSpecifyingQuantity(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.VerifyClusterRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.VerifyClusterRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
VerifyClusterRankingScoreByUserIdResult result = client.verifyClusterRankingScoreByUserId(
new VerifyClusterRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100L)
.withMultiplyValueSpecifyingQuantity(null)
.withTimeOffsetToken(null)
);
ClusterRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.VerifyClusterRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.VerifyClusterRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithVerifyType("less")
.WithSeason(null)
.WithScore(100L)
.WithMultiplyValueSpecifyingQuantity(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.verifyClusterRankingScoreByUserId(
new Gs2Ranking2.VerifyClusterRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100)
.withMultiplyValueSpecifyingQuantity(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.verify_cluster_ranking_score_by_user_id(
ranking2.VerifyClusterRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_verify_type('less')
.with_season(None)
.with_score(100)
.with_multiply_value_specifying_quantity(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.verify_cluster_ranking_score_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=nil,
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('ranking2')
api_result_handler = client.verify_cluster_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=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
item = result.item;
```
---
### describeClusterRankingReceivedRewards
클러스터 랭킹 보상 수령 이력 목록 조회
요청한 사용자의 클러스터 랭킹 보상 수령 이력의 페이지네이션 목록을 조회합니다. 랭킹 이름, 클러스터 이름, 시즌으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | | | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | | | ~ 1024자 | 클러스터 이름
랭킹 보상을 수령한 클러스터의 이름입니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<ClusterRankingReceivedReward>](#clusterrankingreceivedreward) | 클러스터 랭킹 보상 수령 이력 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeClusterRankingReceivedRewards(
&ranking2.DescribeClusterRankingReceivedRewardsRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeClusterRankingReceivedRewardsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeClusterRankingReceivedRewards(
(new DescribeClusterRankingReceivedRewardsRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeClusterRankingReceivedRewardsRequest;
import io.gs2.ranking2.result.DescribeClusterRankingReceivedRewardsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeClusterRankingReceivedRewardsResult result = client.describeClusterRankingReceivedRewards(
new DescribeClusterRankingReceivedRewardsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(0L)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeClusterRankingReceivedRewards(
new Gs2.Gs2Ranking2.Request.DescribeClusterRankingReceivedRewardsRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeClusterRankingReceivedRewards(
new Gs2Ranking2.DescribeClusterRankingReceivedRewardsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(0)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_cluster_ranking_received_rewards(
ranking2.DescribeClusterRankingReceivedRewardsRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_season(0)
.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('ranking2')
api_result = client.describe_cluster_ranking_received_rewards({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=0,
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('ranking2')
api_result_handler = client.describe_cluster_ranking_received_rewards_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=0,
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;
```
---
### describeClusterRankingReceivedRewardsByUserId
사용자 ID를 지정하여 클러스터 랭킹 보상 수령 이력 목록 조회
지정한 사용자의 클러스터 랭킹 보상 수령 이력의 페이지네이션 목록을 조회합니다. 랭킹 이름, 클러스터 이름, 시즌으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | | | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | | | ~ 1024자 | 클러스터 이름
랭킹 보상을 수령한 클러스터의 이름입니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<ClusterRankingReceivedReward>](#clusterrankingreceivedreward) | 클러스터 랭킹 보상 수령 이력 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeClusterRankingReceivedRewardsByUserId(
&ranking2.DescribeClusterRankingReceivedRewardsByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeClusterRankingReceivedRewardsByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeClusterRankingReceivedRewardsByUserId(
(new DescribeClusterRankingReceivedRewardsByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeClusterRankingReceivedRewardsByUserIdRequest;
import io.gs2.ranking2.result.DescribeClusterRankingReceivedRewardsByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeClusterRankingReceivedRewardsByUserIdResult result = client.describeClusterRankingReceivedRewardsByUserId(
new DescribeClusterRankingReceivedRewardsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(null)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeClusterRankingReceivedRewardsByUserId(
new Gs2.Gs2Ranking2.Request.DescribeClusterRankingReceivedRewardsByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeClusterRankingReceivedRewardsByUserId(
new Gs2Ranking2.DescribeClusterRankingReceivedRewardsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(null)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_cluster_ranking_received_rewards_by_user_id(
ranking2.DescribeClusterRankingReceivedRewardsByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_season(None)
.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('ranking2')
api_result = client.describe_cluster_ranking_received_rewards_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=nil,
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('ranking2')
api_result_handler = client.describe_cluster_ranking_received_rewards_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=nil,
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;
```
---
### createClusterRankingReceivedReward
클러스터 랭킹 보상 수령 이력 기록
지정한 클러스터 랭킹 및 클러스터의 보상 수령 이력을 기록합니다. 실제로 보상을 수령하기 전에 이 기록이 필요합니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
랭킹 보상을 수령한 클러스터의 이름입니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingReceivedReward](#clusterrankingreceivedreward) | 클러스터 랭킹 보상 수령 이력 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CreateClusterRankingReceivedReward(
&ranking2.CreateClusterRankingReceivedRewardRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
AccessToken: pointy.String("accessToken-0001"),
Season: pointy.Int64(0),
}
)
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CreateClusterRankingReceivedRewardRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->createClusterRankingReceivedReward(
(new CreateClusterRankingReceivedRewardRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withAccessToken("accessToken-0001")
->withSeason(0)
);
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CreateClusterRankingReceivedRewardRequest;
import io.gs2.ranking2.result.CreateClusterRankingReceivedRewardResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
CreateClusterRankingReceivedRewardResult result = client.createClusterRankingReceivedReward(
new CreateClusterRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withAccessToken("accessToken-0001")
.withSeason(0L)
);
ClusterRankingReceivedReward 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateClusterRankingReceivedReward(
new Gs2.Gs2Ranking2.Request.CreateClusterRankingReceivedRewardRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithAccessToken("accessToken-0001")
.WithSeason(0L),
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.createClusterRankingReceivedReward(
new Gs2Ranking2.CreateClusterRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withAccessToken("accessToken-0001")
.withSeason(0)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.create_cluster_ranking_received_reward(
ranking2.CreateClusterRankingReceivedRewardRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_access_token('accessToken-0001')
.with_season(0)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.create_cluster_ranking_received_reward({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
accessToken="accessToken-0001",
season=0,
})
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('ranking2')
api_result_handler = client.create_cluster_ranking_received_reward_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
accessToken="accessToken-0001",
season=0,
})
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;
```
---
### createClusterRankingReceivedRewardByUserId
사용자 ID를 지정하여 클러스터 랭킹 보상 수령 이력 기록
지정한 사용자를 대신하여, 지정한 클러스터 랭킹 및 클러스터의 보상 수령 이력을 기록합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
랭킹 보상을 수령한 클러스터의 이름입니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingReceivedReward](#clusterrankingreceivedreward) | 클러스터 랭킹 보상 수령 이력 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CreateClusterRankingReceivedRewardByUserId(
&ranking2.CreateClusterRankingReceivedRewardByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
UserId: pointy.String("user-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CreateClusterRankingReceivedRewardByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->createClusterRankingReceivedRewardByUserId(
(new CreateClusterRankingReceivedRewardByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withUserId("user-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CreateClusterRankingReceivedRewardByUserIdRequest;
import io.gs2.ranking2.result.CreateClusterRankingReceivedRewardByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
CreateClusterRankingReceivedRewardByUserIdResult result = client.createClusterRankingReceivedRewardByUserId(
new CreateClusterRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(0L)
.withTimeOffsetToken(null)
);
ClusterRankingReceivedReward 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateClusterRankingReceivedRewardByUserId(
new Gs2.Gs2Ranking2.Request.CreateClusterRankingReceivedRewardByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithUserId("user-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.createClusterRankingReceivedRewardByUserId(
new Gs2Ranking2.CreateClusterRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(0)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.create_cluster_ranking_received_reward_by_user_id(
ranking2.CreateClusterRankingReceivedRewardByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_user_id('user-0001')
.with_season(0)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.create_cluster_ranking_received_reward_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=0,
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('ranking2')
api_result_handler = client.create_cluster_ranking_received_reward_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=0,
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;
```
---
### receiveClusterRankingReceivedReward
클러스터 랭킹 보상 수령
지정한 클러스터 랭킹, 클러스터, 시즌의 랭킹 보상을 수령합니다. 보상은 사용자의 랭킹 순위와 랭킹 모델의 보상 설정에 따라 결정됩니다. 보상 아이템을 부여하기 위한 트랜잭션이 발행됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
랭킹 보상을 수령한 클러스터의 이름입니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| config | [List<Config>](#config) | | | [] | 0 ~ 32 items | 트랜잭션 변수에 적용할 설정값 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingModel](#clusterrankingmodel) | 클러스터 랭킹 모델 |
| acquireActions | [List<AcquireAction>](#acquireaction) | 보상 수령 시 실행되는 입수 액션 목록 |
| 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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.ReceiveClusterRankingReceivedReward(
&ranking2.ReceiveClusterRankingReceivedRewardRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
Season: pointy.Int64(0),
Config: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
acquireActions := result.AcquireActions
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\ReceiveClusterRankingReceivedRewardRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->receiveClusterRankingReceivedReward(
(new ReceiveClusterRankingReceivedRewardRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withSeason(0)
->withConfig(null)
);
$item = $result->getItem();
$acquireActions = $result->getAcquireActions();
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.ReceiveClusterRankingReceivedRewardRequest;
import io.gs2.ranking2.result.ReceiveClusterRankingReceivedRewardResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
ReceiveClusterRankingReceivedRewardResult result = client.receiveClusterRankingReceivedReward(
new ReceiveClusterRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(0L)
.withConfig(null)
);
ClusterRankingModel item = result.getItem();
List acquireActions = result.getAcquireActions();
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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.ReceiveClusterRankingReceivedReward(
new Gs2.Gs2Ranking2.Request.ReceiveClusterRankingReceivedRewardRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithSeason(0L)
.WithConfig(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var acquireActions = result.AcquireActions;
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.receiveClusterRankingReceivedReward(
new Gs2Ranking2.ReceiveClusterRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(0)
.withConfig(null)
);
const item = result.getItem();
const acquireActions = result.getAcquireActions();
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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.receive_cluster_ranking_received_reward(
ranking2.ReceiveClusterRankingReceivedRewardRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_season(0)
.with_config(None)
)
item = result.item
acquire_actions = result.acquire_actions
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('ranking2')
api_result = client.receive_cluster_ranking_received_reward({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=0,
config=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
acquireActions = result.acquireActions;
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('ranking2')
api_result_handler = client.receive_cluster_ranking_received_reward_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=0,
config=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
acquireActions = result.acquireActions;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### receiveClusterRankingReceivedRewardByUserId
사용자 ID를 지정하여 클러스터 랭킹 보상 수령
지정한 사용자를 대신하여, 지정한 클러스터 랭킹, 클러스터, 시즌의 랭킹 보상을 수령합니다. 보상 아이템을 부여하기 위한 트랜잭션이 발행됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
랭킹 보상을 수령한 클러스터의 이름입니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| config | [List<Config>](#config) | | | [] | 0 ~ 32 items | 트랜잭션 변수에 적용할 설정값 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingModel](#clusterrankingmodel) | 클러스터 랭킹 모델 |
| acquireActions | [List<AcquireAction>](#acquireaction) | 보상 수령 시 실행되는 입수 액션 목록 |
| 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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.ReceiveClusterRankingReceivedRewardByUserId(
&ranking2.ReceiveClusterRankingReceivedRewardByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
Season: pointy.Int64(0),
Config: nil,
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
acquireActions := result.AcquireActions
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\ReceiveClusterRankingReceivedRewardByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->receiveClusterRankingReceivedRewardByUserId(
(new ReceiveClusterRankingReceivedRewardByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withSeason(0)
->withConfig(null)
->withTimeOffsetToken(null)
);
$item = $result->getItem();
$acquireActions = $result->getAcquireActions();
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.ReceiveClusterRankingReceivedRewardByUserIdRequest;
import io.gs2.ranking2.result.ReceiveClusterRankingReceivedRewardByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
ReceiveClusterRankingReceivedRewardByUserIdResult result = client.receiveClusterRankingReceivedRewardByUserId(
new ReceiveClusterRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(0L)
.withConfig(null)
.withTimeOffsetToken(null)
);
ClusterRankingModel item = result.getItem();
List acquireActions = result.getAcquireActions();
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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.ReceiveClusterRankingReceivedRewardByUserId(
new Gs2.Gs2Ranking2.Request.ReceiveClusterRankingReceivedRewardByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithSeason(0L)
.WithConfig(null)
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
var acquireActions = result.AcquireActions;
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.receiveClusterRankingReceivedRewardByUserId(
new Gs2Ranking2.ReceiveClusterRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(0)
.withConfig(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
const acquireActions = result.getAcquireActions();
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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.receive_cluster_ranking_received_reward_by_user_id(
ranking2.ReceiveClusterRankingReceivedRewardByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_season(0)
.with_config(None)
.with_time_offset_token(None)
)
item = result.item
acquire_actions = result.acquire_actions
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('ranking2')
api_result = client.receive_cluster_ranking_received_reward_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=0,
config=nil,
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;
acquireActions = result.acquireActions;
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('ranking2')
api_result_handler = client.receive_cluster_ranking_received_reward_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=0,
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
item = result.item;
acquireActions = result.acquireActions;
transactionId = result.transactionId;
stampSheet = result.stampSheet;
stampSheetEncryptionKeyId = result.stampSheetEncryptionKeyId;
autoRunStampSheet = result.autoRunStampSheet;
atomicCommit = result.atomicCommit;
transaction = result.transaction;
transactionResult = result.transactionResult;
```
---
### getClusterRankingReceivedReward
클러스터 랭킹 보상 수령 이력 조회
지정한 클러스터 랭킹 및 클러스터의 보상 수령 이력을 조회합니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
랭킹 보상을 수령한 클러스터의 이름입니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingReceivedReward](#clusterrankingreceivedreward) | 클러스터 랭킹 보상 수령 이력 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetClusterRankingReceivedReward(
&ranking2.GetClusterRankingReceivedRewardRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
AccessToken: pointy.String("accessToken-0001"),
Season: pointy.Int64(0),
}
)
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetClusterRankingReceivedRewardRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getClusterRankingReceivedReward(
(new GetClusterRankingReceivedRewardRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withAccessToken("accessToken-0001")
->withSeason(0)
);
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetClusterRankingReceivedRewardRequest;
import io.gs2.ranking2.result.GetClusterRankingReceivedRewardResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetClusterRankingReceivedRewardResult result = client.getClusterRankingReceivedReward(
new GetClusterRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withAccessToken("accessToken-0001")
.withSeason(0L)
);
ClusterRankingReceivedReward 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetClusterRankingReceivedReward(
new Gs2.Gs2Ranking2.Request.GetClusterRankingReceivedRewardRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithAccessToken("accessToken-0001")
.WithSeason(0L),
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getClusterRankingReceivedReward(
new Gs2Ranking2.GetClusterRankingReceivedRewardRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withAccessToken("accessToken-0001")
.withSeason(0)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_cluster_ranking_received_reward(
ranking2.GetClusterRankingReceivedRewardRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_access_token('accessToken-0001')
.with_season(0)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_cluster_ranking_received_reward({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
accessToken="accessToken-0001",
season=0,
})
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('ranking2')
api_result_handler = client.get_cluster_ranking_received_reward_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
accessToken="accessToken-0001",
season=0,
})
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;
```
---
### getClusterRankingReceivedRewardByUserId
사용자 ID를 지정하여 클러스터 랭킹 보상 수령 이력 조회
지정한 사용자의 지정한 클러스터 랭킹 및 클러스터의 보상 수령 이력을 조회합니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
랭킹 보상을 수령한 클러스터의 이름입니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingReceivedReward](#clusterrankingreceivedreward) | 클러스터 랭킹 보상 수령 이력 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetClusterRankingReceivedRewardByUserId(
&ranking2.GetClusterRankingReceivedRewardByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
UserId: pointy.String("user-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetClusterRankingReceivedRewardByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getClusterRankingReceivedRewardByUserId(
(new GetClusterRankingReceivedRewardByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withUserId("user-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetClusterRankingReceivedRewardByUserIdRequest;
import io.gs2.ranking2.result.GetClusterRankingReceivedRewardByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetClusterRankingReceivedRewardByUserIdResult result = client.getClusterRankingReceivedRewardByUserId(
new GetClusterRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(0L)
.withTimeOffsetToken(null)
);
ClusterRankingReceivedReward 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetClusterRankingReceivedRewardByUserId(
new Gs2.Gs2Ranking2.Request.GetClusterRankingReceivedRewardByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithUserId("user-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getClusterRankingReceivedRewardByUserId(
new Gs2Ranking2.GetClusterRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(0)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_cluster_ranking_received_reward_by_user_id(
ranking2.GetClusterRankingReceivedRewardByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_user_id('user-0001')
.with_season(0)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_cluster_ranking_received_reward_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=0,
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('ranking2')
api_result_handler = client.get_cluster_ranking_received_reward_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=0,
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;
```
---
### deleteClusterRankingReceivedRewardByUserId
사용자 ID를 지정하여 클러스터 랭킹 보상 수령 이력 삭제
지정한 사용자의 지정한 랭킹, 클러스터, 시즌의 클러스터 랭킹 보상 수령 이력을 삭제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
랭킹 보상을 수령한 클러스터의 이름입니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | ✓| | 0 ~ 9223372036854775805 | 시즌
GS2-Schedule 이벤트의 반복 횟수에 대응하는 시즌 번호입니다. |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingReceivedReward](#clusterrankingreceivedreward) | 삭제한 클러스터 랭킹 보상 수령 이력 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteClusterRankingReceivedRewardByUserId(
&ranking2.DeleteClusterRankingReceivedRewardByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
UserId: pointy.String("user-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteClusterRankingReceivedRewardByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->deleteClusterRankingReceivedRewardByUserId(
(new DeleteClusterRankingReceivedRewardByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withUserId("user-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteClusterRankingReceivedRewardByUserIdRequest;
import io.gs2.ranking2.result.DeleteClusterRankingReceivedRewardByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DeleteClusterRankingReceivedRewardByUserIdResult result = client.deleteClusterRankingReceivedRewardByUserId(
new DeleteClusterRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(0L)
.withTimeOffsetToken(null)
);
ClusterRankingReceivedReward 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteClusterRankingReceivedRewardByUserId(
new Gs2.Gs2Ranking2.Request.DeleteClusterRankingReceivedRewardByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithUserId("user-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteClusterRankingReceivedRewardByUserId(
new Gs2Ranking2.DeleteClusterRankingReceivedRewardByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(0)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_cluster_ranking_received_reward_by_user_id(
ranking2.DeleteClusterRankingReceivedRewardByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_user_id('user-0001')
.with_season(0)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.delete_cluster_ranking_received_reward_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=0,
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('ranking2')
api_result_handler = client.delete_cluster_ranking_received_reward_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=0,
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;
```
---
### describeClusterRankings
클러스터 랭킹 목록 조회
지정한 랭킹 및 클러스터의 클러스터 랭킹 데이터의 페이지네이션 목록을 조회합니다. 랭킹 데이터에는 순위, 스코어, 사용자 정보가 포함됩니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 시즌이 속한 클러스터(길드, 게더링, 또는 그룹)의 이름입니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<ClusterRankingData>](#clusterrankingdata) | 클러스터 랭킹 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeClusterRankings(
&ranking2.DescribeClusterRankingsRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
Season: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeClusterRankingsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeClusterRankings(
(new DescribeClusterRankingsRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withSeason(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeClusterRankingsRequest;
import io.gs2.ranking2.result.DescribeClusterRankingsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeClusterRankingsResult result = client.describeClusterRankings(
new DescribeClusterRankingsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeClusterRankings(
new Gs2.Gs2Ranking2.Request.DescribeClusterRankingsRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithSeason(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeClusterRankings(
new Gs2Ranking2.DescribeClusterRankingsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_cluster_rankings(
ranking2.DescribeClusterRankingsRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_season(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('ranking2')
api_result = client.describe_cluster_rankings({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=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('ranking2')
api_result_handler = client.describe_cluster_rankings_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=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;
```
---
### describeClusterRankingsByUserId
사용자 ID를 지정하여 클러스터 랭킹 목록 조회
지정한 사용자를 대신하여, 지정한 랭킹 및 클러스터의 클러스터 랭킹 데이터의 페이지네이션 목록을 조회합니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 시즌이 속한 클러스터(길드, 게더링, 또는 그룹)의 이름입니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<ClusterRankingData>](#clusterrankingdata) | 클러스터 랭킹 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeClusterRankingsByUserId(
&ranking2.DescribeClusterRankingsByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeClusterRankingsByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeClusterRankingsByUserId(
(new DescribeClusterRankingsByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeClusterRankingsByUserIdRequest;
import io.gs2.ranking2.result.DescribeClusterRankingsByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeClusterRankingsByUserIdResult result = client.describeClusterRankingsByUserId(
new DescribeClusterRankingsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(null)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeClusterRankingsByUserId(
new Gs2.Gs2Ranking2.Request.DescribeClusterRankingsByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeClusterRankingsByUserId(
new Gs2Ranking2.DescribeClusterRankingsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withSeason(null)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_cluster_rankings_by_user_id(
ranking2.DescribeClusterRankingsByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_season(None)
.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('ranking2')
api_result = client.describe_cluster_rankings_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=nil,
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('ranking2')
api_result_handler = client.describe_cluster_rankings_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
season=nil,
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;
```
---
### getClusterRanking
클러스터 랭킹 조회
지정한 클러스터 랭킹에서 요청한 사용자의 순위와 스코어를 조회합니다. 랭킹 데이터는 클러스터 내에 등록된 스코어로부터 계산됩니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 시즌이 속한 클러스터(길드, 게더링, 또는 그룹)의 이름입니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingData](#clusterrankingdata) | 클러스터 랭킹 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetClusterRanking(
&ranking2.GetClusterRankingRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
AccessToken: pointy.String("accessToken-0001"),
Season: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetClusterRankingRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getClusterRanking(
(new GetClusterRankingRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withAccessToken("accessToken-0001")
->withSeason(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetClusterRankingRequest;
import io.gs2.ranking2.result.GetClusterRankingResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetClusterRankingResult result = client.getClusterRanking(
new GetClusterRankingRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withAccessToken("accessToken-0001")
.withSeason(null)
);
ClusterRankingData 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetClusterRanking(
new Gs2.Gs2Ranking2.Request.GetClusterRankingRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithAccessToken("accessToken-0001")
.WithSeason(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getClusterRanking(
new Gs2Ranking2.GetClusterRankingRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withAccessToken("accessToken-0001")
.withSeason(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_cluster_ranking(
ranking2.GetClusterRankingRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_access_token('accessToken-0001')
.with_season(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_cluster_ranking({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
accessToken="accessToken-0001",
season=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('ranking2')
api_result_handler = client.get_cluster_ranking_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
accessToken="accessToken-0001",
season=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;
```
---
### getClusterRankingByUserId
사용자 ID를 지정하여 클러스터 랭킹 조회
지정한 클러스터 랭킹에서 지정한 사용자의 순위와 스코어를 조회합니다. 시즌을 선택적으로 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| clusterName | string | | ✓| | ~ 1024자 | 클러스터 이름
이 시즌이 속한 클러스터(길드, 게더링, 또는 그룹)의 이름입니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingData](#clusterrankingdata) | 클러스터 랭킹 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetClusterRankingByUserId(
&ranking2.GetClusterRankingByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
ClusterName: pointy.String("cluster-0001"),
UserId: pointy.String("user-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetClusterRankingByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getClusterRankingByUserId(
(new GetClusterRankingByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withClusterName("cluster-0001")
->withUserId("user-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetClusterRankingByUserIdRequest;
import io.gs2.ranking2.result.GetClusterRankingByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetClusterRankingByUserIdResult result = client.getClusterRankingByUserId(
new GetClusterRankingByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(null)
.withTimeOffsetToken(null)
);
ClusterRankingData 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetClusterRankingByUserId(
new Gs2.Gs2Ranking2.Request.GetClusterRankingByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithClusterName("cluster-0001")
.WithUserId("user-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getClusterRankingByUserId(
new Gs2Ranking2.GetClusterRankingByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withClusterName("cluster-0001")
.withUserId("user-0001")
.withSeason(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_cluster_ranking_by_user_id(
ranking2.GetClusterRankingByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_cluster_name('cluster-0001')
.with_user_id('user-0001')
.with_season(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_cluster_ranking_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=nil,
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('ranking2')
api_result_handler = client.get_cluster_ranking_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
clusterName="cluster-0001",
userId="user-0001",
season=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
item = result.item;
```
---
### describeSubscribes
구독 대상 사용자 정보 목록 취득
요청한 사용자가 구독 랭킹을 위해 구독하고 있는 사용자의 페이지네이션이 포함된 목록을 취득합니다. 랭킹 이름으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SubscribeUser>](#subscribeuser) | 구독 대상 사용자 정보 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeSubscribes(
&ranking2.DescribeSubscribesRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeSubscribesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeSubscribes(
(new DescribeSubscribesRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeSubscribesRequest;
import io.gs2.ranking2.result.DescribeSubscribesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeSubscribesResult result = client.describeSubscribes(
new DescribeSubscribesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribes(
new Gs2.Gs2Ranking2.Request.DescribeSubscribesRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeSubscribes(
new Gs2Ranking2.DescribeSubscribesRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_subscribes(
ranking2.DescribeSubscribesRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-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('ranking2')
api_result = client.describe_subscribes({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-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('ranking2')
api_result_handler = client.describe_subscribes_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-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;
```
---
### describeSubscribesByUserId
사용자 ID를 지정하여 구독 대상 사용자 정보 목록 취득
지정한 사용자가 구독 랭킹을 위해 구독하고 있는 사용자의 페이지네이션이 포함된 목록을 취득합니다. 랭킹 이름으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SubscribeUser>](#subscribeuser) | 구독 대상 사용자 정보 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeSubscribesByUserId(
&ranking2.DescribeSubscribesByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeSubscribesByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeSubscribesByUserId(
(new DescribeSubscribesByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeSubscribesByUserIdRequest;
import io.gs2.ranking2.result.DescribeSubscribesByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeSubscribesByUserIdResult result = client.describeSubscribesByUserId(
new DescribeSubscribesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribesByUserId(
new Gs2.Gs2Ranking2.Request.DescribeSubscribesByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeSubscribesByUserId(
new Gs2Ranking2.DescribeSubscribesByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_subscribes_by_user_id(
ranking2.DescribeSubscribesByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-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('ranking2')
api_result = client.describe_subscribes_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-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('ranking2')
api_result_handler = client.describe_subscribes_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-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;
```
---
### addSubscribe
구독 대상 사용자 ID 등록
지정한 구독 랭킹에서 지정한 대상 사용자를 구독합니다. 대상 사용자의 스코어가 요청한 사용자의 구독 랭킹에 포함됩니다. 구독이 추가되면 대상 사용자의 기존 스코어가 구독자의 랭킹 데이터에 동기화됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| targetUserId | string | | ✓| | ~ 128자 | 구독 대상 사용자 ID |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 등록한 구독 대상 사용자 정보 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.AddSubscribe(
&ranking2.AddSubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
TargetUserId: pointy.String("user-0002"),
}
)
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\AddSubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->addSubscribe(
(new AddSubscribeRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withTargetUserId("user-0002")
);
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.AddSubscribeRequest;
import io.gs2.ranking2.result.AddSubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
AddSubscribeResult result = client.addSubscribe(
new AddSubscribeRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
SubscribeUser 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.AddSubscribe(
new Gs2.Gs2Ranking2.Request.AddSubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithTargetUserId("user-0002"),
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.addSubscribe(
new Gs2Ranking2.AddSubscribeRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.add_subscribe(
ranking2.AddSubscribeRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_target_user_id('user-0002')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.add_subscribe({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
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('ranking2')
api_result_handler = client.add_subscribe_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
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;
```
---
### addSubscribeByUserId
사용자 ID를 지정하여 구독 대상 사용자 ID 등록
지정한 사용자를 대신하여, 지정한 구독 랭킹에서 지정한 대상 사용자를 구독합니다. 기존 스코어가 구독자의 랭킹 데이터에 동기화됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| targetUserId | string | | ✓| | ~ 128자 | 구독 대상 사용자 ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 등록한 구독 대상 사용자 정보 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.AddSubscribeByUserId(
&ranking2.AddSubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
TargetUserId: pointy.String("user-0002"),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\AddSubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->addSubscribeByUserId(
(new AddSubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withTargetUserId("user-0002")
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.AddSubscribeByUserIdRequest;
import io.gs2.ranking2.result.AddSubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
AddSubscribeByUserIdResult result = client.addSubscribeByUserId(
new AddSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
SubscribeUser 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.AddSubscribeByUserId(
new Gs2.Gs2Ranking2.Request.AddSubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithTargetUserId("user-0002")
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.addSubscribeByUserId(
new Gs2Ranking2.AddSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.add_subscribe_by_user_id(
ranking2.AddSubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_target_user_id('user-0002')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.add_subscribe_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
targetUserId="user-0002",
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('ranking2')
api_result_handler = client.add_subscribe_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
targetUserId="user-0002",
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;
```
---
### describeSubscribeRankingScores
구독 랭킹 스코어 목록 취득
요청한 사용자가 등록한 구독 랭킹 스코어의 페이지네이션이 포함된 목록을 취득합니다. 랭킹 이름으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | | | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SubscribeRankingScore>](#subscriberankingscore) | 구독 랭킹 스코어 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeSubscribeRankingScores(
&ranking2.DescribeSubscribeRankingScoresRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeSubscribeRankingScoresRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeSubscribeRankingScores(
(new DescribeSubscribeRankingScoresRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeSubscribeRankingScoresRequest;
import io.gs2.ranking2.result.DescribeSubscribeRankingScoresResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeSubscribeRankingScoresResult result = client.describeSubscribeRankingScores(
new DescribeSubscribeRankingScoresRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribeRankingScores(
new Gs2.Gs2Ranking2.Request.DescribeSubscribeRankingScoresRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeSubscribeRankingScores(
new Gs2Ranking2.DescribeSubscribeRankingScoresRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_subscribe_ranking_scores(
ranking2.DescribeSubscribeRankingScoresRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-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('ranking2')
api_result = client.describe_subscribe_ranking_scores({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-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('ranking2')
api_result_handler = client.describe_subscribe_ranking_scores_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-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;
```
---
### describeSubscribeRankingScoresByUserId
사용자 ID를 지정하여 구독 랭킹 스코어 목록 취득
지정한 사용자가 등록한 구독 랭킹 스코어의 페이지네이션이 포함된 목록을 취득합니다. 랭킹 이름으로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | | | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SubscribeRankingScore>](#subscriberankingscore) | 구독 랭킹 스코어 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeSubscribeRankingScoresByUserId(
&ranking2.DescribeSubscribeRankingScoresByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeSubscribeRankingScoresByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeSubscribeRankingScoresByUserId(
(new DescribeSubscribeRankingScoresByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeSubscribeRankingScoresByUserIdRequest;
import io.gs2.ranking2.result.DescribeSubscribeRankingScoresByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeSubscribeRankingScoresByUserIdResult result = client.describeSubscribeRankingScoresByUserId(
new DescribeSubscribeRankingScoresByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName(null)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribeRankingScoresByUserId(
new Gs2.Gs2Ranking2.Request.DescribeSubscribeRankingScoresByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeSubscribeRankingScoresByUserId(
new Gs2Ranking2.DescribeSubscribeRankingScoresByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName(null)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_subscribe_ranking_scores_by_user_id(
ranking2.DescribeSubscribeRankingScoresByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name(None)
.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('ranking2')
api_result = client.describe_subscribe_ranking_scores_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName=nil,
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('ranking2')
api_result_handler = client.describe_subscribe_ranking_scores_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName=nil,
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;
```
---
### putSubscribeRankingScore
구독 랭킹 스코어 등록
지정한 구독 랭킹에 스코어를 등록합니다. 스코어는 모든 구독자의 랭킹 데이터에 반영됩니다. 스코어는 랭킹 모델에서 정의된 범위 내에 있어야 합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어 |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingScore](#subscriberankingscore) | 등록한 구독 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.PutSubscribeRankingScore(
&ranking2.PutSubscribeRankingScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
Score: pointy.Int64(100),
Metadata: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\PutSubscribeRankingScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->putSubscribeRankingScore(
(new PutSubscribeRankingScoreRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withScore(100)
->withMetadata(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.PutSubscribeRankingScoreRequest;
import io.gs2.ranking2.result.PutSubscribeRankingScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
PutSubscribeRankingScoreResult result = client.putSubscribeRankingScore(
new PutSubscribeRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withScore(100L)
.withMetadata(null)
);
SubscribeRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.PutSubscribeRankingScore(
new Gs2.Gs2Ranking2.Request.PutSubscribeRankingScoreRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithScore(100L)
.WithMetadata(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.putSubscribeRankingScore(
new Gs2Ranking2.PutSubscribeRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withScore(100)
.withMetadata(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.put_subscribe_ranking_score(
ranking2.PutSubscribeRankingScoreRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_score(100)
.with_metadata(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.put_subscribe_ranking_score({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
score=100,
metadata=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking2')
api_result_handler = client.put_subscribe_ranking_score_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
score=100,
metadata=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### putSubscribeRankingScoreByUserId
사용자 ID를 지정하여 구독 랭킹 스코어 등록
지정한 사용자를 대신하여, 지정한 구독 랭킹에 스코어를 등록합니다. 스코어는 모든 구독자의 랭킹 데이터에 반영됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어 |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingScore](#subscriberankingscore) | 등록한 구독 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.PutSubscribeRankingScoreByUserId(
&ranking2.PutSubscribeRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Score: nil,
Metadata: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\PutSubscribeRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->putSubscribeRankingScoreByUserId(
(new PutSubscribeRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withScore(null)
->withMetadata(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.PutSubscribeRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.PutSubscribeRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
PutSubscribeRankingScoreByUserIdResult result = client.putSubscribeRankingScoreByUserId(
new PutSubscribeRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withScore(null)
.withMetadata(null)
.withTimeOffsetToken(null)
);
SubscribeRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.PutSubscribeRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.PutSubscribeRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithScore(null)
.WithMetadata(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.putSubscribeRankingScoreByUserId(
new Gs2Ranking2.PutSubscribeRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withScore(null)
.withMetadata(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.put_subscribe_ranking_score_by_user_id(
ranking2.PutSubscribeRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_score(None)
.with_metadata(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.put_subscribe_ranking_score_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
score=nil,
metadata=nil,
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('ranking2')
api_result_handler = client.put_subscribe_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
score=nil,
metadata=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
item = result.item;
```
---
### getSubscribeRankingScore
구독 랭킹 스코어 취득
지정한 랭킹에 대해 요청한 사용자가 등록한 구독 랭킹 스코어를 취득합니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingScore](#subscriberankingscore) | 구독 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetSubscribeRankingScore(
&ranking2.GetSubscribeRankingScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
Season: pointy.Int64(0),
}
)
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetSubscribeRankingScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getSubscribeRankingScore(
(new GetSubscribeRankingScoreRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withSeason(0)
);
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetSubscribeRankingScoreRequest;
import io.gs2.ranking2.result.GetSubscribeRankingScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetSubscribeRankingScoreResult result = client.getSubscribeRankingScore(
new GetSubscribeRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(0L)
);
SubscribeRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribeRankingScore(
new Gs2.Gs2Ranking2.Request.GetSubscribeRankingScoreRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithSeason(0L),
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getSubscribeRankingScore(
new Gs2Ranking2.GetSubscribeRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(0)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_subscribe_ranking_score(
ranking2.GetSubscribeRankingScoreRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_season(0)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_subscribe_ranking_score({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=0,
})
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('ranking2')
api_result_handler = client.get_subscribe_ranking_score_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=0,
})
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;
```
---
### getSubscribeRankingScoreByUserId
사용자 ID를 지정하여 구독 랭킹 스코어 취득
지정한 랭킹에 대해 지정한 사용자가 등록한 구독 랭킹 스코어를 취득합니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingScore](#subscriberankingscore) | 구독 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetSubscribeRankingScoreByUserId(
&ranking2.GetSubscribeRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetSubscribeRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getSubscribeRankingScoreByUserId(
(new GetSubscribeRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetSubscribeRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.GetSubscribeRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetSubscribeRankingScoreByUserIdResult result = client.getSubscribeRankingScoreByUserId(
new GetSubscribeRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(null)
.withTimeOffsetToken(null)
);
SubscribeRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribeRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.GetSubscribeRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getSubscribeRankingScoreByUserId(
new Gs2Ranking2.GetSubscribeRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_subscribe_ranking_score_by_user_id(
ranking2.GetSubscribeRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_season(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_subscribe_ranking_score_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=nil,
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('ranking2')
api_result_handler = client.get_subscribe_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=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
item = result.item;
```
---
### deleteSubscribeRankingScoreByUserId
사용자 ID를 지정하여 구독 랭킹 스코어 삭제
지정한 사용자가 지정한 랭킹 및 시즌에 등록한 구독 랭킹 스코어를 삭제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingScore](#subscriberankingscore) | 삭제한 구독 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteSubscribeRankingScoreByUserId(
&ranking2.DeleteSubscribeRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Season: pointy.Int64(0),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteSubscribeRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->deleteSubscribeRankingScoreByUserId(
(new DeleteSubscribeRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withSeason(0)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteSubscribeRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.DeleteSubscribeRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DeleteSubscribeRankingScoreByUserIdResult result = client.deleteSubscribeRankingScoreByUserId(
new DeleteSubscribeRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(0L)
.withTimeOffsetToken(null)
);
SubscribeRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteSubscribeRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.DeleteSubscribeRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithSeason(0L)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteSubscribeRankingScoreByUserId(
new Gs2Ranking2.DeleteSubscribeRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(0)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_subscribe_ranking_score_by_user_id(
ranking2.DeleteSubscribeRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_season(0)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.delete_subscribe_ranking_score_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=0,
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('ranking2')
api_result_handler = client.delete_subscribe_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=0,
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;
```
---
### verifySubscribeRankingScore
구독 랭킹의 스코어를 검증
구독 랭킹 스코어를 비교 연산자(less, lessEqual, greater, greaterEqual, equal, notEqual)를 사용하여 지정한 값과 비교 검증합니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| verifyType | 문자열 열거형
enum {
"less",
"lessEqual",
"greater",
"greaterEqual",
"equal",
"notEqual"
}
| | ✓| | | 검증 종류less: 스코어가 지정값 미만일 것 / lessEqual: 스코어가 지정값 이하일 것 / greater: 스코어가 지정값 초과일 것 / greaterEqual: 스코어가 지정값 이상일 것 / equal: 스코어가 지정값과 일치할 것 / notEqual: 스코어가 지정값과 일치하지 않을 것 / |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어 |
| multiplyValueSpecifyingQuantity | bool | | | true | | 수량을 지정했을 때, 검증에 사용하는 값도 곱할지 여부 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingScore](#subscriberankingscore) | 구독 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.VerifySubscribeRankingScore(
&ranking2.VerifySubscribeRankingScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
VerifyType: pointy.String("less"),
Season: nil,
Score: pointy.Int64(100),
MultiplyValueSpecifyingQuantity: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\VerifySubscribeRankingScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->verifySubscribeRankingScore(
(new VerifySubscribeRankingScoreRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withVerifyType("less")
->withSeason(null)
->withScore(100)
->withMultiplyValueSpecifyingQuantity(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.VerifySubscribeRankingScoreRequest;
import io.gs2.ranking2.result.VerifySubscribeRankingScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
VerifySubscribeRankingScoreResult result = client.verifySubscribeRankingScore(
new VerifySubscribeRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100L)
.withMultiplyValueSpecifyingQuantity(null)
);
SubscribeRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.VerifySubscribeRankingScore(
new Gs2.Gs2Ranking2.Request.VerifySubscribeRankingScoreRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithVerifyType("less")
.WithSeason(null)
.WithScore(100L)
.WithMultiplyValueSpecifyingQuantity(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.verifySubscribeRankingScore(
new Gs2Ranking2.VerifySubscribeRankingScoreRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100)
.withMultiplyValueSpecifyingQuantity(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.verify_subscribe_ranking_score(
ranking2.VerifySubscribeRankingScoreRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_verify_type('less')
.with_season(None)
.with_score(100)
.with_multiply_value_specifying_quantity(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.verify_subscribe_ranking_score({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=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('ranking2')
api_result_handler = client.verify_subscribe_ranking_score_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=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;
```
---
### verifySubscribeRankingScoreByUserId
사용자 ID를 지정하여 구독 랭킹의 스코어를 검증
지정한 사용자의 구독 랭킹 스코어를 비교 연산자(less, lessEqual, greater, greaterEqual, equal, notEqual)를 사용하여 지정한 값과 비교 검증합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| verifyType | 문자열 열거형
enum {
"less",
"lessEqual",
"greater",
"greaterEqual",
"equal",
"notEqual"
}
| | ✓| | | 검증 종류less: 스코어가 지정값 미만일 것 / lessEqual: 스코어가 지정값 이하일 것 / greater: 스코어가 지정값 초과일 것 / greaterEqual: 스코어가 지정값 이상일 것 / equal: 스코어가 지정값과 일치할 것 / notEqual: 스코어가 지정값과 일치하지 않을 것 / |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어 |
| multiplyValueSpecifyingQuantity | bool | | | true | | 수량을 지정했을 때, 검증에 사용하는 값도 곱할지 여부 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingScore](#subscriberankingscore) | 구독 랭킹 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.VerifySubscribeRankingScoreByUserId(
&ranking2.VerifySubscribeRankingScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-0001"),
VerifyType: pointy.String("less"),
Season: nil,
Score: pointy.Int64(100),
MultiplyValueSpecifyingQuantity: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\VerifySubscribeRankingScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->verifySubscribeRankingScoreByUserId(
(new VerifySubscribeRankingScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-0001")
->withVerifyType("less")
->withSeason(null)
->withScore(100)
->withMultiplyValueSpecifyingQuantity(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.VerifySubscribeRankingScoreByUserIdRequest;
import io.gs2.ranking2.result.VerifySubscribeRankingScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
VerifySubscribeRankingScoreByUserIdResult result = client.verifySubscribeRankingScoreByUserId(
new VerifySubscribeRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100L)
.withMultiplyValueSpecifyingQuantity(null)
.withTimeOffsetToken(null)
);
SubscribeRankingScore 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.VerifySubscribeRankingScoreByUserId(
new Gs2.Gs2Ranking2.Request.VerifySubscribeRankingScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-0001")
.WithVerifyType("less")
.WithSeason(null)
.WithScore(100L)
.WithMultiplyValueSpecifyingQuantity(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.verifySubscribeRankingScoreByUserId(
new Gs2Ranking2.VerifySubscribeRankingScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withVerifyType("less")
.withSeason(null)
.withScore(100)
.withMultiplyValueSpecifyingQuantity(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.verify_subscribe_ranking_score_by_user_id(
ranking2.VerifySubscribeRankingScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-0001')
.with_verify_type('less')
.with_season(None)
.with_score(100)
.with_multiply_value_specifying_quantity(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.verify_subscribe_ranking_score_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=nil,
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('ranking2')
api_result_handler = client.verify_subscribe_ranking_score_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
verifyType="less",
season=nil,
score=100,
multiplyValueSpecifyingQuantity=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
item = result.item;
```
---
### describeSubscribeRankings
구독 랭킹 목록 취득
지정한 랭킹의 구독 랭킹 데이터의 페이지네이션이 포함된 목록을 취득합니다. 랭킹에는 요청한 사용자가 구독하고 있는 사용자의 스코어만 포함됩니다. 옵션으로 시즌을 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SubscribeRankingData>](#subscriberankingdata) | 구독 랭킹 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeSubscribeRankings(
&ranking2.DescribeSubscribeRankingsRequest {
NamespaceName: pointy.String("namespace-0001"),
AccessToken: pointy.String("accessToken-0001"),
RankingName: pointy.String("ranking-0001"),
Season: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeSubscribeRankingsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeSubscribeRankings(
(new DescribeSubscribeRankingsRequest())
->withNamespaceName("namespace-0001")
->withAccessToken("accessToken-0001")
->withRankingName("ranking-0001")
->withSeason(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeSubscribeRankingsRequest;
import io.gs2.ranking2.result.DescribeSubscribeRankingsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeSubscribeRankingsResult result = client.describeSubscribeRankings(
new DescribeSubscribeRankingsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withSeason(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribeRankings(
new Gs2.Gs2Ranking2.Request.DescribeSubscribeRankingsRequest()
.WithNamespaceName("namespace-0001")
.WithAccessToken("accessToken-0001")
.WithRankingName("ranking-0001")
.WithSeason(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeSubscribeRankings(
new Gs2Ranking2.DescribeSubscribeRankingsRequest()
.withNamespaceName("namespace-0001")
.withAccessToken("accessToken-0001")
.withRankingName("ranking-0001")
.withSeason(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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_subscribe_rankings(
ranking2.DescribeSubscribeRankingsRequest()
.with_namespace_name('namespace-0001')
.with_access_token('accessToken-0001')
.with_ranking_name('ranking-0001')
.with_season(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('ranking2')
api_result = client.describe_subscribe_rankings({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
season=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('ranking2')
api_result_handler = client.describe_subscribe_rankings_async({
namespaceName="namespace-0001",
accessToken="accessToken-0001",
rankingName="ranking-0001",
season=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;
```
---
### describeSubscribeRankingsByUserId
사용자 ID를 지정하여 구독 랭킹 목록 취득
지정한 사용자를 대신하여, 지정한 랭킹의 구독 랭킹 데이터의 페이지네이션이 포함된 목록을 취득합니다. 랭킹에는 지정한 사용자가 구독하고 있는 사용자의 스코어만 포함됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SubscribeRankingData>](#subscriberankingdata) | 구독 랭킹 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeSubscribeRankingsByUserId(
&ranking2.DescribeSubscribeRankingsByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
UserId: pointy.String("user-0001"),
RankingName: pointy.String("ranking-0001"),
Season: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeSubscribeRankingsByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeSubscribeRankingsByUserId(
(new DescribeSubscribeRankingsByUserIdRequest())
->withNamespaceName("namespace-0001")
->withUserId("user-0001")
->withRankingName("ranking-0001")
->withSeason(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeSubscribeRankingsByUserIdRequest;
import io.gs2.ranking2.result.DescribeSubscribeRankingsByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeSubscribeRankingsByUserIdResult result = client.describeSubscribeRankingsByUserId(
new DescribeSubscribeRankingsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withSeason(null)
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribeRankingsByUserId(
new Gs2.Gs2Ranking2.Request.DescribeSubscribeRankingsByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithUserId("user-0001")
.WithRankingName("ranking-0001")
.WithSeason(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeSubscribeRankingsByUserId(
new Gs2Ranking2.DescribeSubscribeRankingsByUserIdRequest()
.withNamespaceName("namespace-0001")
.withUserId("user-0001")
.withRankingName("ranking-0001")
.withSeason(null)
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_subscribe_rankings_by_user_id(
ranking2.DescribeSubscribeRankingsByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_user_id('user-0001')
.with_ranking_name('ranking-0001')
.with_season(None)
.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('ranking2')
api_result = client.describe_subscribe_rankings_by_user_id({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
season=nil,
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('ranking2')
api_result_handler = client.describe_subscribe_rankings_by_user_id_async({
namespaceName="namespace-0001",
userId="user-0001",
rankingName="ranking-0001",
season=nil,
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;
```
---
### getSubscribeRanking
구독 랭킹 취득
구독 랭킹 내 요청한 사용자(또는 지정한 스코어러)의 순위와 스코어를 취득합니다. 옵션으로 시즌과 스코어러 사용자 ID를 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| scorerUserId | string | | | | ~ 128자 | 점수를 획득한 사용자ID
이 점수를 달성한 플레이어의 사용자ID입니다. 구독 랭킹에서는 구독한 사용자의 점수가 엔트리가 되므로, 이 필드는 어느 친구의 점수인지를 식별합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingData](#subscriberankingdata) | 구독 랭킹 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetSubscribeRanking(
&ranking2.GetSubscribeRankingRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
Season: nil,
ScorerUserId: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetSubscribeRankingRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getSubscribeRanking(
(new GetSubscribeRankingRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withSeason(null)
->withScorerUserId(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetSubscribeRankingRequest;
import io.gs2.ranking2.result.GetSubscribeRankingResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetSubscribeRankingResult result = client.getSubscribeRanking(
new GetSubscribeRankingRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(null)
.withScorerUserId(null)
);
SubscribeRankingData 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribeRanking(
new Gs2.Gs2Ranking2.Request.GetSubscribeRankingRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithSeason(null)
.WithScorerUserId(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getSubscribeRanking(
new Gs2Ranking2.GetSubscribeRankingRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withSeason(null)
.withScorerUserId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_subscribe_ranking(
ranking2.GetSubscribeRankingRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_season(None)
.with_scorer_user_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_subscribe_ranking({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=nil,
scorerUserId=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('ranking2')
api_result_handler = client.get_subscribe_ranking_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
season=nil,
scorerUserId=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;
```
---
### getSubscribeRankingByUserId
사용자 ID를 지정하여 구독 랭킹 취득
구독 랭킹 내 지정한 사용자(또는 지정한 스코어러)의 순위와 스코어를 취득합니다. 옵션으로 시즌과 스코어러 사용자 ID를 지정할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| season | long | | | | 0 ~ 9223372036854775805 | 시즌 |
| scorerUserId | string | | | | ~ 128자 | 점수를 획득한 사용자ID
이 점수를 달성한 플레이어의 사용자ID입니다. 구독 랭킹에서는 구독한 사용자의 점수가 엔트리가 되므로, 이 필드는 어느 친구의 점수인지를 식별합니다. |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingData](#subscriberankingdata) | 구독 랭킹 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetSubscribeRankingByUserId(
&ranking2.GetSubscribeRankingByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
Season: nil,
ScorerUserId: nil,
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetSubscribeRankingByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getSubscribeRankingByUserId(
(new GetSubscribeRankingByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withSeason(null)
->withScorerUserId(null)
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetSubscribeRankingByUserIdRequest;
import io.gs2.ranking2.result.GetSubscribeRankingByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetSubscribeRankingByUserIdResult result = client.getSubscribeRankingByUserId(
new GetSubscribeRankingByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(null)
.withScorerUserId(null)
.withTimeOffsetToken(null)
);
SubscribeRankingData 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribeRankingByUserId(
new Gs2.Gs2Ranking2.Request.GetSubscribeRankingByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithSeason(null)
.WithScorerUserId(null)
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getSubscribeRankingByUserId(
new Gs2Ranking2.GetSubscribeRankingByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withSeason(null)
.withScorerUserId(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_subscribe_ranking_by_user_id(
ranking2.GetSubscribeRankingByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_season(None)
.with_scorer_user_id(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_subscribe_ranking_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=nil,
scorerUserId=nil,
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('ranking2')
api_result_handler = client.get_subscribe_ranking_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
season=nil,
scorerUserId=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
item = result.item;
```
---
### getSubscribe
구독 대상 사용자 ID 취득
지정한 구독 랭킹에서 지정한 대상 사용자의 구독 정보를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| targetUserId | string | | ✓| | ~ 128자 | 구독 대상 사용자 ID |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 구독 대상 사용자 정보 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetSubscribe(
&ranking2.GetSubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
TargetUserId: pointy.String("user-0002"),
}
)
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetSubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getSubscribe(
(new GetSubscribeRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withTargetUserId("user-0002")
);
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetSubscribeRequest;
import io.gs2.ranking2.result.GetSubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetSubscribeResult result = client.getSubscribe(
new GetSubscribeRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
SubscribeUser 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribe(
new Gs2.Gs2Ranking2.Request.GetSubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithTargetUserId("user-0002"),
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getSubscribe(
new Gs2Ranking2.GetSubscribeRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_subscribe(
ranking2.GetSubscribeRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_target_user_id('user-0002')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_subscribe({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
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('ranking2')
api_result_handler = client.get_subscribe_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
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;
```
---
### getSubscribeByUserId
사용자 ID를 지정하여 구독 대상 사용자 ID 취득
지정한 사용자에 있어서, 지정한 구독 랭킹의 지정한 대상 사용자의 구독 정보를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| targetUserId | string | | ✓| | ~ 128자 | 구독 대상 사용자 ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 구독 대상 사용자 정보 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetSubscribeByUserId(
&ranking2.GetSubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
TargetUserId: pointy.String("user-0002"),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetSubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getSubscribeByUserId(
(new GetSubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withTargetUserId("user-0002")
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetSubscribeByUserIdRequest;
import io.gs2.ranking2.result.GetSubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetSubscribeByUserIdResult result = client.getSubscribeByUserId(
new GetSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
SubscribeUser 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribeByUserId(
new Gs2.Gs2Ranking2.Request.GetSubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithTargetUserId("user-0002")
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getSubscribeByUserId(
new Gs2Ranking2.GetSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_subscribe_by_user_id(
ranking2.GetSubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_target_user_id('user-0002')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_subscribe_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
targetUserId="user-0002",
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('ranking2')
api_result_handler = client.get_subscribe_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
targetUserId="user-0002",
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;
```
---
### deleteSubscribe
구독 대상 사용자 ID 삭제
지정한 구독 랭킹에서 지정한 대상 사용자의 구독을 해제합니다. 대상 사용자의 스코어는 더 이상 요청한 사용자의 구독 랭킹에 표시되지 않습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| targetUserId | string | | ✓| | ~ 128자 | 구독 대상 사용자 ID |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 삭제한 구독 대상 사용자 정보 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteSubscribe(
&ranking2.DeleteSubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
AccessToken: pointy.String("accessToken-0001"),
TargetUserId: pointy.String("user-0002"),
}
)
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteSubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->deleteSubscribe(
(new DeleteSubscribeRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withAccessToken("accessToken-0001")
->withTargetUserId("user-0002")
);
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteSubscribeRequest;
import io.gs2.ranking2.result.DeleteSubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DeleteSubscribeResult result = client.deleteSubscribe(
new DeleteSubscribeRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
SubscribeUser 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteSubscribe(
new Gs2.Gs2Ranking2.Request.DeleteSubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithAccessToken("accessToken-0001")
.WithTargetUserId("user-0002"),
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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteSubscribe(
new Gs2Ranking2.DeleteSubscribeRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withAccessToken("accessToken-0001")
.withTargetUserId("user-0002")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_subscribe(
ranking2.DeleteSubscribeRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_access_token('accessToken-0001')
.with_target_user_id('user-0002')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.delete_subscribe({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
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('ranking2')
api_result_handler = client.delete_subscribe_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
accessToken="accessToken-0001",
targetUserId="user-0002",
})
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;
```
---
### deleteSubscribeByUserId
사용자 ID를 지정하여 구독 대상 사용자 ID 삭제
지정한 사용자를 대신하여, 지정한 구독 랭킹에서 지정한 대상 사용자의 구독을 해제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| targetUserId | string | | ✓| | ~ 128자 | 구독 대상 사용자 ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeUser](#subscribeuser) | 삭제한 구독 대상 사용자 정보 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteSubscribeByUserId(
&ranking2.DeleteSubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-0001"),
UserId: pointy.String("user-0001"),
TargetUserId: pointy.String("user-0002"),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteSubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->deleteSubscribeByUserId(
(new DeleteSubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-0001")
->withUserId("user-0001")
->withTargetUserId("user-0002")
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteSubscribeByUserIdRequest;
import io.gs2.ranking2.result.DeleteSubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DeleteSubscribeByUserIdResult result = client.deleteSubscribeByUserId(
new DeleteSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
SubscribeUser 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteSubscribeByUserId(
new Gs2.Gs2Ranking2.Request.DeleteSubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-0001")
.WithUserId("user-0001")
.WithTargetUserId("user-0002")
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteSubscribeByUserId(
new Gs2Ranking2.DeleteSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
.withUserId("user-0001")
.withTargetUserId("user-0002")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_subscribe_by_user_id(
ranking2.DeleteSubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
.with_user_id('user-0001')
.with_target_user_id('user-0002')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.delete_subscribe_by_user_id({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
targetUserId="user-0002",
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('ranking2')
api_result_handler = client.delete_subscribe_by_user_id_async({
namespaceName="namespace-0001",
rankingName="ranking-0001",
userId="user-0001",
targetUserId="user-0002",
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;
```
---
### describeGlobalRankingModels
글로벌 랭킹 모델 목록 취득
현재 활성화된 글로벌 랭킹 모델의 목록을 취득합니다. 글로벌 랭킹 모델은 스코어 범위, 정렬 순서, 보상 설정, 진입/접근 기간 이벤트 등의 랭킹 설정을 정의합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<GlobalRankingModel>](#globalrankingmodel) | 글로벌 랭킹 모델 목록 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeGlobalRankingModels(
&ranking2.DescribeGlobalRankingModelsRequest {
NamespaceName: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeGlobalRankingModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeGlobalRankingModels(
(new DescribeGlobalRankingModelsRequest())
->withNamespaceName(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeGlobalRankingModelsRequest;
import io.gs2.ranking2.result.DescribeGlobalRankingModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeGlobalRankingModelsResult result = client.describeGlobalRankingModels(
new DescribeGlobalRankingModelsRequest()
.withNamespaceName(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeGlobalRankingModels(
new Gs2.Gs2Ranking2.Request.DescribeGlobalRankingModelsRequest()
.WithNamespaceName(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeGlobalRankingModels(
new Gs2Ranking2.DescribeGlobalRankingModelsRequest()
.withNamespaceName(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_global_ranking_models(
ranking2.DescribeGlobalRankingModelsRequest()
.with_namespace_name(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.describe_global_ranking_models({
namespaceName=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('ranking2')
api_result_handler = client.describe_global_ranking_models_async({
namespaceName=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;
```
---
### getGlobalRankingModel
글로벌 랭킹 모델 취득
스코어 범위, 정렬 순서, 랭킹 보상, 진입/접근 기간 이벤트 설정을 포함한 지정된 글로벌 랭킹 모델을 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingModel](#globalrankingmodel) | 글로벌 랭킹 모델 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetGlobalRankingModel(
&ranking2.GetGlobalRankingModelRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetGlobalRankingModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getGlobalRankingModel(
(new GetGlobalRankingModelRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetGlobalRankingModelRequest;
import io.gs2.ranking2.result.GetGlobalRankingModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetGlobalRankingModelResult result = client.getGlobalRankingModel(
new GetGlobalRankingModelRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
);
GlobalRankingModel 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetGlobalRankingModel(
new Gs2.Gs2Ranking2.Request.GetGlobalRankingModelRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getGlobalRankingModel(
new Gs2Ranking2.GetGlobalRankingModelRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_global_ranking_model(
ranking2.GetGlobalRankingModelRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_global_ranking_model({
namespaceName="namespace-0001",
rankingName="ranking-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('ranking2')
api_result_handler = client.get_global_ranking_model_async({
namespaceName="namespace-0001",
rankingName="ranking-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;
```
---
### describeClusterRankingModels
클러스터 랭킹 모델 목록 조회
현재 활성화된 클러스터 랭킹 모델의 목록을 조회합니다. 클러스터 랭킹 모델은 클러스터 타입(길드 또는 매치메이킹 개더링), 스코어 범위, 정렬 순서, 보상 설정, 참가/접근 기간 이벤트 등의 랭킹 설정을 정의합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<ClusterRankingModel>](#clusterrankingmodel) | 클러스터 랭킹 모델 목록 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeClusterRankingModels(
&ranking2.DescribeClusterRankingModelsRequest {
NamespaceName: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeClusterRankingModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeClusterRankingModels(
(new DescribeClusterRankingModelsRequest())
->withNamespaceName(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeClusterRankingModelsRequest;
import io.gs2.ranking2.result.DescribeClusterRankingModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeClusterRankingModelsResult result = client.describeClusterRankingModels(
new DescribeClusterRankingModelsRequest()
.withNamespaceName(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeClusterRankingModels(
new Gs2.Gs2Ranking2.Request.DescribeClusterRankingModelsRequest()
.WithNamespaceName(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeClusterRankingModels(
new Gs2Ranking2.DescribeClusterRankingModelsRequest()
.withNamespaceName(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_cluster_ranking_models(
ranking2.DescribeClusterRankingModelsRequest()
.with_namespace_name(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.describe_cluster_ranking_models({
namespaceName=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('ranking2')
api_result_handler = client.describe_cluster_ranking_models_async({
namespaceName=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;
```
---
### getClusterRankingModel
클러스터 랭킹 모델 조회
클러스터 타입, 스코어 범위, 정렬 순서, 랭킹 보상, 참가/접근 기간 이벤트 설정을 포함하여 지정된 클러스터 랭킹 모델을 조회합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingModel](#clusterrankingmodel) | 클러스터 랭킹 모델 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetClusterRankingModel(
&ranking2.GetClusterRankingModelRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetClusterRankingModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getClusterRankingModel(
(new GetClusterRankingModelRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetClusterRankingModelRequest;
import io.gs2.ranking2.result.GetClusterRankingModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetClusterRankingModelResult result = client.getClusterRankingModel(
new GetClusterRankingModelRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
);
ClusterRankingModel 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetClusterRankingModel(
new Gs2.Gs2Ranking2.Request.GetClusterRankingModelRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getClusterRankingModel(
new Gs2Ranking2.GetClusterRankingModelRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_cluster_ranking_model(
ranking2.GetClusterRankingModelRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_cluster_ranking_model({
namespaceName="namespace-0001",
rankingName="ranking-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('ranking2')
api_result_handler = client.get_cluster_ranking_model_async({
namespaceName="namespace-0001",
rankingName="ranking-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;
```
---
### describeSubscribeRankingModels
구독 랭킹 모델 목록 조회
현재 활성화된 구독 랭킹 모델의 목록을 조회합니다. 구독 랭킹 모델은 구독한 친구와만 경쟁하는 랭킹 설정을 정의하며, 스코어 범위, 정렬 순서, 참가/접근 기간 이벤트 등을 포함합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SubscribeRankingModel>](#subscriberankingmodel) | 구독 랭킹 모델 목록 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeSubscribeRankingModels(
&ranking2.DescribeSubscribeRankingModelsRequest {
NamespaceName: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeSubscribeRankingModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeSubscribeRankingModels(
(new DescribeSubscribeRankingModelsRequest())
->withNamespaceName(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeSubscribeRankingModelsRequest;
import io.gs2.ranking2.result.DescribeSubscribeRankingModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeSubscribeRankingModelsResult result = client.describeSubscribeRankingModels(
new DescribeSubscribeRankingModelsRequest()
.withNamespaceName(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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribeRankingModels(
new Gs2.Gs2Ranking2.Request.DescribeSubscribeRankingModelsRequest()
.WithNamespaceName(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeSubscribeRankingModels(
new Gs2Ranking2.DescribeSubscribeRankingModelsRequest()
.withNamespaceName(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_subscribe_ranking_models(
ranking2.DescribeSubscribeRankingModelsRequest()
.with_namespace_name(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.describe_subscribe_ranking_models({
namespaceName=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('ranking2')
api_result_handler = client.describe_subscribe_ranking_models_async({
namespaceName=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;
```
---
### getSubscribeRankingModel
구독 랭킹 모델 조회
스코어 범위, 정렬 순서, 참가/접근 기간 이벤트 설정을 포함하여 지정된 구독 랭킹 모델을 조회합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델 이름
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingModel](#subscriberankingmodel) | 구독 랭킹 모델 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetSubscribeRankingModel(
&ranking2.GetSubscribeRankingModelRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("ranking-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetSubscribeRankingModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getSubscribeRankingModel(
(new GetSubscribeRankingModelRequest())
->withNamespaceName("namespace-0001")
->withRankingName("ranking-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetSubscribeRankingModelRequest;
import io.gs2.ranking2.result.GetSubscribeRankingModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetSubscribeRankingModelResult result = client.getSubscribeRankingModel(
new GetSubscribeRankingModelRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
);
SubscribeRankingModel 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribeRankingModel(
new Gs2.Gs2Ranking2.Request.GetSubscribeRankingModelRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("ranking-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getSubscribeRankingModel(
new Gs2Ranking2.GetSubscribeRankingModelRequest()
.withNamespaceName("namespace-0001")
.withRankingName("ranking-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_subscribe_ranking_model(
ranking2.GetSubscribeRankingModelRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('ranking-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_subscribe_ranking_model({
namespaceName="namespace-0001",
rankingName="ranking-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('ranking2')
api_result_handler = client.get_subscribe_ranking_model_async({
namespaceName="namespace-0001",
rankingName="ranking-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 | [CurrentRankingMaster](#currentrankingmaster) | 활성화 가능한 마스터 데이터 형식으로 모델 마스터 내보내기 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.ExportMaster(
&ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\ExportMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.ExportMasterRequest;
import io.gs2.ranking2.result.ExportMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
ExportMasterResult result = client.exportMaster(
new ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentRankingMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.ExportMaster(
new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.exportMaster(
new Gs2Ranking2.ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.export_master(
ranking2.ExportMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
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('ranking2')
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;
```
---
### getCurrentRankingMaster
현재 활성화된 랭킹 모델의 마스터 데이터 조회
글로벌, 클러스터, 구독 랭킹 모델 정의를 포함한 현재 활성화된 랭킹 모델의 마스터 데이터를 조회합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentRankingMaster](#currentrankingmaster) | 현재 활성화된 랭킹 모델의 마스터 데이터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetCurrentRankingMaster(
&ranking2.GetCurrentRankingMasterRequest {
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetCurrentRankingMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getCurrentRankingMaster(
(new GetCurrentRankingMasterRequest())
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetCurrentRankingMasterRequest;
import io.gs2.ranking2.result.GetCurrentRankingMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetCurrentRankingMasterResult result = client.getCurrentRankingMaster(
new GetCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
);
CurrentRankingMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCurrentRankingMaster(
new Gs2.Gs2Ranking2.Request.GetCurrentRankingMasterRequest()
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getCurrentRankingMaster(
new Gs2Ranking2.GetCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_current_ranking_master(
ranking2.GetCurrentRankingMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_current_ranking_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('ranking2')
api_result_handler = client.get_current_ranking_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;
```
---
### preUpdateCurrentRankingMaster
현재 활성화된 랭킹 모델의 마스터 데이터 업데이트（3단계 버전）
1MB를 초과하는 마스터 데이터를 업로드하는 경우, 3단계로 업데이트를 수행합니다.
1. 이 API를 실행하여 업로드용 토큰과 URL을 획득합니다.
2. 획득한 URL에 마스터 데이터를 업로드합니다.
3. UpdateCurrentRankingMaster 에 업로드로 획득한 토큰을 전달하여 실행하고, 마스터 데이터를 반영합니다.
#### 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/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.PreUpdateCurrentRankingMaster(
&ranking2.PreUpdateCurrentRankingMasterRequest {
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\PreUpdateCurrentRankingMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->preUpdateCurrentRankingMaster(
(new PreUpdateCurrentRankingMasterRequest())
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.PreUpdateCurrentRankingMasterRequest;
import io.gs2.ranking2.result.PreUpdateCurrentRankingMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
PreUpdateCurrentRankingMasterResult result = client.preUpdateCurrentRankingMaster(
new PreUpdateCurrentRankingMasterRequest()
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.PreUpdateCurrentRankingMaster(
new Gs2.Gs2Ranking2.Request.PreUpdateCurrentRankingMasterRequest()
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.preUpdateCurrentRankingMaster(
new Gs2Ranking2.PreUpdateCurrentRankingMasterRequest()
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.pre_update_current_ranking_master(
ranking2.PreUpdateCurrentRankingMasterRequest()
.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('ranking2')
api_result = client.pre_update_current_ranking_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('ranking2')
api_result_handler = client.pre_update_current_ranking_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;
```
---
### updateCurrentRankingMaster
현재 활성화된 랭킹 모델의 마스터 데이터 업데이트
현재 활성화된 랭킹 모델의 마스터 데이터를 업데이트합니다. 대용량 마스터 데이터에 대응하기 위해, 직접 업데이트 모드와 사전 업로드 모드를 모두 지원합니다.
#### 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 | [CurrentRankingMaster](#currentrankingmaster) | 업데이트된 현재 활성화된 랭킹 모델의 마스터 데이터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.UpdateCurrentRankingMaster(
&ranking2.UpdateCurrentRankingMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Mode: pointy.String("direct"),
Settings: pointy.String("{\"version\": \"2024-05-30\", \"globalRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}], \"clusterRankingModels\": [{\"name\": \"ranking-0001\", \"clusterType\": \"Raw\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"clusterType\": \"Gs2Guild::Guild\", \"orderDirection\": \"desc\"}], \"subscribeRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}]}"),
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\UpdateCurrentRankingMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->updateCurrentRankingMaster(
(new UpdateCurrentRankingMasterRequest())
->withNamespaceName("namespace-0001")
->withMode("direct")
->withSettings("{\"version\": \"2024-05-30\", \"globalRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}], \"clusterRankingModels\": [{\"name\": \"ranking-0001\", \"clusterType\": \"Raw\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"clusterType\": \"Gs2Guild::Guild\", \"orderDirection\": \"desc\"}], \"subscribeRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}]}")
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.UpdateCurrentRankingMasterRequest;
import io.gs2.ranking2.result.UpdateCurrentRankingMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
UpdateCurrentRankingMasterResult result = client.updateCurrentRankingMaster(
new UpdateCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\"version\": \"2024-05-30\", \"globalRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}], \"clusterRankingModels\": [{\"name\": \"ranking-0001\", \"clusterType\": \"Raw\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"clusterType\": \"Gs2Guild::Guild\", \"orderDirection\": \"desc\"}], \"subscribeRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}]}")
.withUploadToken(null)
);
CurrentRankingMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentRankingMaster(
new Gs2.Gs2Ranking2.Request.UpdateCurrentRankingMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMode("direct")
.WithSettings("{\"version\": \"2024-05-30\", \"globalRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}], \"clusterRankingModels\": [{\"name\": \"ranking-0001\", \"clusterType\": \"Raw\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"clusterType\": \"Gs2Guild::Guild\", \"orderDirection\": \"desc\"}], \"subscribeRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}]}")
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.updateCurrentRankingMaster(
new Gs2Ranking2.UpdateCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\"version\": \"2024-05-30\", \"globalRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}], \"clusterRankingModels\": [{\"name\": \"ranking-0001\", \"clusterType\": \"Raw\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"clusterType\": \"Gs2Guild::Guild\", \"orderDirection\": \"desc\"}], \"subscribeRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}]}")
.withUploadToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.update_current_ranking_master(
ranking2.UpdateCurrentRankingMasterRequest()
.with_namespace_name('namespace-0001')
.with_mode('direct')
.with_settings('{"version": "2024-05-30", "globalRankingModels": [{"name": "ranking-0001", "orderDirection": "asc"}, {"name": "ranking-0002", "orderDirection": "desc"}], "clusterRankingModels": [{"name": "ranking-0001", "clusterType": "Raw", "orderDirection": "asc"}, {"name": "ranking-0002", "clusterType": "Gs2Guild::Guild", "orderDirection": "desc"}], "subscribeRankingModels": [{"name": "ranking-0001", "orderDirection": "asc"}, {"name": "ranking-0002", "orderDirection": "desc"}]}')
.with_upload_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.update_current_ranking_master({
namespaceName="namespace-0001",
mode="direct",
settings="{\"version\": \"2024-05-30\", \"globalRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}], \"clusterRankingModels\": [{\"name\": \"ranking-0001\", \"clusterType\": \"Raw\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"clusterType\": \"Gs2Guild::Guild\", \"orderDirection\": \"desc\"}], \"subscribeRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}]}",
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('ranking2')
api_result_handler = client.update_current_ranking_master_async({
namespaceName="namespace-0001",
mode="direct",
settings="{\"version\": \"2024-05-30\", \"globalRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}], \"clusterRankingModels\": [{\"name\": \"ranking-0001\", \"clusterType\": \"Raw\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"clusterType\": \"Gs2Guild::Guild\", \"orderDirection\": \"desc\"}], \"subscribeRankingModels\": [{\"name\": \"ranking-0001\", \"orderDirection\": \"asc\"}, {\"name\": \"ranking-0002\", \"orderDirection\": \"desc\"}]}",
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;
```
---
### updateCurrentRankingMasterFromGitHub
현재 활성화된 랭킹 모델의 마스터 데이터를 GitHub에서 업데이트
지정된 체크아웃 설정을 사용하여 GitHub 리포지토리에서 마스터 데이터를 체크아웃하고, 현재 활성화된 랭킹 모델의 마스터 데이터를 업데이트합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| checkoutSetting | [GitHubCheckoutSetting](#githubcheckoutsetting) | | ✓| | | GitHub에서 마스터 데이터를 체크아웃하는 설정 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CurrentRankingMaster](#currentrankingmaster) | 업데이트된 현재 활성화된 랭킹 모델의 마스터 데이터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.UpdateCurrentRankingMasterFromGitHub(
&ranking2.UpdateCurrentRankingMasterFromGitHubRequest {
NamespaceName: pointy.String("namespace-0001"),
CheckoutSetting: &ranking2.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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\UpdateCurrentRankingMasterFromGitHubRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->updateCurrentRankingMasterFromGitHub(
(new UpdateCurrentRankingMasterFromGitHubRequest())
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.UpdateCurrentRankingMasterFromGitHubRequest;
import io.gs2.ranking2.result.UpdateCurrentRankingMasterFromGitHubResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
UpdateCurrentRankingMasterFromGitHubResult result = client.updateCurrentRankingMasterFromGitHub(
new UpdateCurrentRankingMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new GitHubCheckoutSetting()
.withApiKeyId("apiKeyId-0001")
.withRepositoryName("gs2io/master-data")
.withSourcePath("path/to/file.json")
.withReferenceType("branch")
.withBranchName("develop")
)
);
CurrentRankingMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentRankingMasterFromGitHub(
new Gs2.Gs2Ranking2.Request.UpdateCurrentRankingMasterFromGitHubRequest()
.WithNamespaceName("namespace-0001")
.WithCheckoutSetting(new Gs2.Gs2Ranking2.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.updateCurrentRankingMasterFromGitHub(
new Gs2Ranking2.UpdateCurrentRankingMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new Gs2Ranking2.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.update_current_ranking_master_from_git_hub(
ranking2.UpdateCurrentRankingMasterFromGitHubRequest()
.with_namespace_name('namespace-0001')
.with_checkout_setting(ranking2.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('ranking2')
api_result = client.update_current_ranking_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('ranking2')
api_result_handler = client.update_current_ranking_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;
```
---
### describeGlobalRankingModelMasters
글로벌 랭킹 모델 마스터 목록 조회
글로벌 랭킹 모델 마스터의 페이지네이션 목록을 조회합니다. 이름의 접두사로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| namePrefix | string | | | | ~ 64자 | 글로벌 랭킹 모델 이름의 필터 접두사 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<GlobalRankingModelMaster>](#globalrankingmodelmaster) | 글로벌 랭킹 모델 마스터 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeGlobalRankingModelMasters(
&ranking2.DescribeGlobalRankingModelMastersRequest {
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeGlobalRankingModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeGlobalRankingModelMasters(
(new DescribeGlobalRankingModelMastersRequest())
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeGlobalRankingModelMastersRequest;
import io.gs2.ranking2.result.DescribeGlobalRankingModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeGlobalRankingModelMastersResult result = client.describeGlobalRankingModelMasters(
new DescribeGlobalRankingModelMastersRequest()
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeGlobalRankingModelMasters(
new Gs2.Gs2Ranking2.Request.DescribeGlobalRankingModelMastersRequest()
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeGlobalRankingModelMasters(
new Gs2Ranking2.DescribeGlobalRankingModelMastersRequest()
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_global_ranking_model_masters(
ranking2.DescribeGlobalRankingModelMastersRequest()
.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('ranking2')
api_result = client.describe_global_ranking_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('ranking2')
api_result_handler = client.describe_global_ranking_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;
```
---
### createGlobalRankingModelMaster
글로벌 랭킹 모델 마스터 신규 생성
스코어 범위, 정렬 순서, 합계 모드, 랭킹 보상, 보상 계산 인덱스, 엔트리/액세스 기간 이벤트 설정을 가진 새로운 글로벌 랭킹 모델 마스터를 생성합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| name | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 스코어 최솟값
허용되는 스코어의 최솟값입니다. 이 값보다 낮은 스코어는 등록 시 거부됩니다. 유효하지 않거나 의도하지 않은 스코어 값을 필터링하는 데 사용합니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 스코어 최댓값
허용되는 스코어의 최댓값입니다. 이 값을 초과하는 스코어는 등록 시 거부됩니다. 비정상적으로 높은 스코어의 등록을 방지하는 데 사용합니다. |
| sum | bool | | | false | | 스코어 합산
활성화하면 등록된 모든 스코어가 합산되어 합계 값으로 랭킹이 결정됩니다. 비활성화된 경우, 정렬 방향에 따른 최적의 스코어(최댓값 또는 최솟값)만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓| | | 정렬 방향
랭킹 스코어의 정렬 방향입니다. 낮은 스코어일수록 상위인 경우(예: 타임어택)에는 "오름차순"을, 높은 스코어일수록 상위인 경우(예: 하이스코어)에는 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| rankingRewards | [List<RankingReward>](#rankingreward) | {entryPeriodEventId} != null | | [] | 0 ~ 100 items | 랭킹 보상 목록
각 시즌 종료 시의 랭킹 순위에 따라 지급되는 보상 목록입니다. 스코어 등록 가능 기간 이벤트가 설정되어 있는 경우에만 이용할 수 있습니다. 각 보상은 순위 임계값과 실행할 입수 액션을 정의합니다. |
| rewardCalculationIndex | 문자열 열거형
enum {
"rank",
"index"
}
| | | "rank" | | 보상 계산 인덱스
보상을 플레이어에게 대응시키는 방법을 결정합니다. "순위 기반"은 1부터 시작하는 랭킹 순위를 사용하며(동점 스코어의 플레이어는 동일한 순위를 공유), "인덱스 기반"은 0부터 시작하는 고유한 정렬 위치를 사용합니다(동일 순위 없음). 일반적인 사용 사례에서는 "순위 기반"을 선택하시기 바랍니다.rank: 순위 기반으로 보상 결정 / index: 인덱스 기반으로 보상 결정 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 반복 사이클마다 랭킹이 초기화되어 시즌제 랭킹을 구현할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과의 열람과 보상 수령이 가능한 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 일반적으로 스코어 등록 기간 사이의 간격으로 설정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingModelMaster](#globalrankingmodelmaster) | 생성한 글로벌 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CreateGlobalRankingModelMaster(
&ranking2.CreateGlobalRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("global-0001"),
Description: nil,
Metadata: nil,
MinimumValue: nil,
MaximumValue: nil,
Sum: nil,
OrderDirection: pointy.String("asc"),
RankingRewards: nil,
RewardCalculationIndex: nil,
EntryPeriodEventId: nil,
AccessPeriodEventId: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CreateGlobalRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->createGlobalRankingModelMaster(
(new CreateGlobalRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withName("global-0001")
->withDescription(null)
->withMetadata(null)
->withMinimumValue(null)
->withMaximumValue(null)
->withSum(null)
->withOrderDirection("asc")
->withRankingRewards(null)
->withRewardCalculationIndex(null)
->withEntryPeriodEventId(null)
->withAccessPeriodEventId(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CreateGlobalRankingModelMasterRequest;
import io.gs2.ranking2.result.CreateGlobalRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
CreateGlobalRankingModelMasterResult result = client.createGlobalRankingModelMaster(
new CreateGlobalRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("global-0001")
.withDescription(null)
.withMetadata(null)
.withMinimumValue(null)
.withMaximumValue(null)
.withSum(null)
.withOrderDirection("asc")
.withRankingRewards(null)
.withRewardCalculationIndex(null)
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
GlobalRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateGlobalRankingModelMaster(
new Gs2.Gs2Ranking2.Request.CreateGlobalRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("global-0001")
.WithDescription(null)
.WithMetadata(null)
.WithMinimumValue(null)
.WithMaximumValue(null)
.WithSum(null)
.WithOrderDirection("asc")
.WithRankingRewards(null)
.WithRewardCalculationIndex(null)
.WithEntryPeriodEventId(null)
.WithAccessPeriodEventId(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.createGlobalRankingModelMaster(
new Gs2Ranking2.CreateGlobalRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("global-0001")
.withDescription(null)
.withMetadata(null)
.withMinimumValue(null)
.withMaximumValue(null)
.withSum(null)
.withOrderDirection("asc")
.withRankingRewards(null)
.withRewardCalculationIndex(null)
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.create_global_ranking_model_master(
ranking2.CreateGlobalRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('global-0001')
.with_description(None)
.with_metadata(None)
.with_minimum_value(None)
.with_maximum_value(None)
.with_sum(None)
.with_order_direction('asc')
.with_ranking_rewards(None)
.with_reward_calculation_index(None)
.with_entry_period_event_id(None)
.with_access_period_event_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.create_global_ranking_model_master({
namespaceName="namespace-0001",
name="global-0001",
description=nil,
metadata=nil,
minimumValue=nil,
maximumValue=nil,
sum=nil,
orderDirection="asc",
rankingRewards=nil,
rewardCalculationIndex=nil,
entryPeriodEventId=nil,
accessPeriodEventId=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('ranking2')
api_result_handler = client.create_global_ranking_model_master_async({
namespaceName="namespace-0001",
name="global-0001",
description=nil,
metadata=nil,
minimumValue=nil,
maximumValue=nil,
sum=nil,
orderDirection="asc",
rankingRewards=nil,
rewardCalculationIndex=nil,
entryPeriodEventId=nil,
accessPeriodEventId=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;
```
---
### getGlobalRankingModelMaster
글로벌 랭킹 모델 마스터 조회
지정된 글로벌 랭킹 모델 마스터를 조회합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingModelMaster](#globalrankingmodelmaster) | 글로벌 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetGlobalRankingModelMaster(
&ranking2.GetGlobalRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("global-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetGlobalRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getGlobalRankingModelMaster(
(new GetGlobalRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withRankingName("global-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetGlobalRankingModelMasterRequest;
import io.gs2.ranking2.result.GetGlobalRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetGlobalRankingModelMasterResult result = client.getGlobalRankingModelMaster(
new GetGlobalRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("global-0001")
);
GlobalRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetGlobalRankingModelMaster(
new Gs2.Gs2Ranking2.Request.GetGlobalRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("global-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getGlobalRankingModelMaster(
new Gs2Ranking2.GetGlobalRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("global-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_global_ranking_model_master(
ranking2.GetGlobalRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('global-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_global_ranking_model_master({
namespaceName="namespace-0001",
rankingName="global-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('ranking2')
api_result_handler = client.get_global_ranking_model_master_async({
namespaceName="namespace-0001",
rankingName="global-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;
```
---
### updateGlobalRankingModelMaster
글로벌 랭킹 모델 마스터 업데이트
지정된 글로벌 랭킹 모델 마스터의 스코어 범위, 정렬 순서, 합계 모드, 랭킹 보상, 보상 계산 인덱스, 엔트리/액세스 기간 이벤트 설정을 업데이트합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 스코어 최솟값
허용되는 스코어의 최솟값입니다. 이 값보다 낮은 스코어는 등록 시 거부됩니다. 유효하지 않거나 의도하지 않은 스코어 값을 필터링하는 데 사용합니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 스코어 최댓값
허용되는 스코어의 최댓값입니다. 이 값을 초과하는 스코어는 등록 시 거부됩니다. 비정상적으로 높은 스코어의 등록을 방지하는 데 사용합니다. |
| sum | bool | | | false | | 스코어 합산
활성화하면 등록된 모든 스코어가 합산되어 합계 값으로 랭킹이 결정됩니다. 비활성화된 경우, 정렬 방향에 따른 최적의 스코어(최댓값 또는 최솟값)만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓| | | 정렬 방향
랭킹 스코어의 정렬 방향입니다. 낮은 스코어일수록 상위인 경우(예: 타임어택)에는 "오름차순"을, 높은 스코어일수록 상위인 경우(예: 하이스코어)에는 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| rankingRewards | [List<RankingReward>](#rankingreward) | {entryPeriodEventId} != null | | [] | 0 ~ 100 items | 랭킹 보상 목록
각 시즌 종료 시의 랭킹 순위에 따라 지급되는 보상 목록입니다. 스코어 등록 가능 기간 이벤트가 설정되어 있는 경우에만 이용할 수 있습니다. 각 보상은 순위 임계값과 실행할 입수 액션을 정의합니다. |
| rewardCalculationIndex | 문자열 열거형
enum {
"rank",
"index"
}
| | | "rank" | | 보상 계산 인덱스
보상을 플레이어에게 대응시키는 방법을 결정합니다. "순위 기반"은 1부터 시작하는 랭킹 순위를 사용하며(동점 스코어의 플레이어는 동일한 순위를 공유), "인덱스 기반"은 0부터 시작하는 고유한 정렬 위치를 사용합니다(동일 순위 없음). 일반적인 사용 사례에서는 "순위 기반"을 선택하시기 바랍니다.rank: 순위 기반으로 보상 결정 / index: 인덱스 기반으로 보상 결정 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 반복 사이클마다 랭킹이 초기화되어 시즌제 랭킹을 구현할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과의 열람과 보상 수령이 가능한 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 일반적으로 스코어 등록 기간 사이의 간격으로 설정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingModelMaster](#globalrankingmodelmaster) | 업데이트한 글로벌 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.UpdateGlobalRankingModelMaster(
&ranking2.UpdateGlobalRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("global-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("CATEGORY_0001"),
MinimumValue: pointy.Int64(100),
MaximumValue: pointy.Int64(10000),
Sum: nil,
OrderDirection: pointy.String("desc"),
RankingRewards: nil,
RewardCalculationIndex: nil,
EntryPeriodEventId: nil,
AccessPeriodEventId: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\UpdateGlobalRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->updateGlobalRankingModelMaster(
(new UpdateGlobalRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withRankingName("global-0001")
->withDescription("description1")
->withMetadata("CATEGORY_0001")
->withMinimumValue(100)
->withMaximumValue(10000)
->withSum(null)
->withOrderDirection("desc")
->withRankingRewards(null)
->withRewardCalculationIndex(null)
->withEntryPeriodEventId(null)
->withAccessPeriodEventId(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.UpdateGlobalRankingModelMasterRequest;
import io.gs2.ranking2.result.UpdateGlobalRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
UpdateGlobalRankingModelMasterResult result = client.updateGlobalRankingModelMaster(
new UpdateGlobalRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("global-0001")
.withDescription("description1")
.withMetadata("CATEGORY_0001")
.withMinimumValue(100L)
.withMaximumValue(10000L)
.withSum(null)
.withOrderDirection("desc")
.withRankingRewards(null)
.withRewardCalculationIndex(null)
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
GlobalRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateGlobalRankingModelMaster(
new Gs2.Gs2Ranking2.Request.UpdateGlobalRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("global-0001")
.WithDescription("description1")
.WithMetadata("CATEGORY_0001")
.WithMinimumValue(100L)
.WithMaximumValue(10000L)
.WithSum(null)
.WithOrderDirection("desc")
.WithRankingRewards(null)
.WithRewardCalculationIndex(null)
.WithEntryPeriodEventId(null)
.WithAccessPeriodEventId(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.updateGlobalRankingModelMaster(
new Gs2Ranking2.UpdateGlobalRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("global-0001")
.withDescription("description1")
.withMetadata("CATEGORY_0001")
.withMinimumValue(100)
.withMaximumValue(10000)
.withSum(null)
.withOrderDirection("desc")
.withRankingRewards(null)
.withRewardCalculationIndex(null)
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.update_global_ranking_model_master(
ranking2.UpdateGlobalRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('global-0001')
.with_description('description1')
.with_metadata('CATEGORY_0001')
.with_minimum_value(100)
.with_maximum_value(10000)
.with_sum(None)
.with_order_direction('desc')
.with_ranking_rewards(None)
.with_reward_calculation_index(None)
.with_entry_period_event_id(None)
.with_access_period_event_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.update_global_ranking_model_master({
namespaceName="namespace-0001",
rankingName="global-0001",
description="description1",
metadata="CATEGORY_0001",
minimumValue=100,
maximumValue=10000,
sum=nil,
orderDirection="desc",
rankingRewards=nil,
rewardCalculationIndex=nil,
entryPeriodEventId=nil,
accessPeriodEventId=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('ranking2')
api_result_handler = client.update_global_ranking_model_master_async({
namespaceName="namespace-0001",
rankingName="global-0001",
description="description1",
metadata="CATEGORY_0001",
minimumValue=100,
maximumValue=10000,
sum=nil,
orderDirection="desc",
rankingRewards=nil,
rewardCalculationIndex=nil,
entryPeriodEventId=nil,
accessPeriodEventId=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;
```
---
### deleteGlobalRankingModelMaster
글로벌 랭킹 모델 마스터 삭제
지정된 글로벌 랭킹 모델 마스터를 삭제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 글로벌 랭킹 모델 이름
글로벌 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [GlobalRankingModelMaster](#globalrankingmodelmaster) | 삭제한 글로벌 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteGlobalRankingModelMaster(
&ranking2.DeleteGlobalRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("global-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteGlobalRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->deleteGlobalRankingModelMaster(
(new DeleteGlobalRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withRankingName("global-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteGlobalRankingModelMasterRequest;
import io.gs2.ranking2.result.DeleteGlobalRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DeleteGlobalRankingModelMasterResult result = client.deleteGlobalRankingModelMaster(
new DeleteGlobalRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("global-0001")
);
GlobalRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteGlobalRankingModelMaster(
new Gs2.Gs2Ranking2.Request.DeleteGlobalRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("global-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteGlobalRankingModelMaster(
new Gs2Ranking2.DeleteGlobalRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("global-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_global_ranking_model_master(
ranking2.DeleteGlobalRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('global-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.delete_global_ranking_model_master({
namespaceName="namespace-0001",
rankingName="global-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('ranking2')
api_result_handler = client.delete_global_ranking_model_master_async({
namespaceName="namespace-0001",
rankingName="global-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;
```
---
### describeClusterRankingModelMasters
클러스터 랭킹 모델 마스터 목록 조회
클러스터 랭킹 모델 마스터의 페이지네이션 지원 목록을 조회합니다. 이름의 접두사로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| namePrefix | string | | | | ~ 64자 | 클러스터 랭킹 모델명 필터 접두사 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<ClusterRankingModelMaster>](#clusterrankingmodelmaster) | 클러스터 랭킹 모델 마스터 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeClusterRankingModelMasters(
&ranking2.DescribeClusterRankingModelMastersRequest {
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeClusterRankingModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeClusterRankingModelMasters(
(new DescribeClusterRankingModelMastersRequest())
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeClusterRankingModelMastersRequest;
import io.gs2.ranking2.result.DescribeClusterRankingModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeClusterRankingModelMastersResult result = client.describeClusterRankingModelMasters(
new DescribeClusterRankingModelMastersRequest()
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeClusterRankingModelMasters(
new Gs2.Gs2Ranking2.Request.DescribeClusterRankingModelMastersRequest()
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeClusterRankingModelMasters(
new Gs2Ranking2.DescribeClusterRankingModelMastersRequest()
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_cluster_ranking_model_masters(
ranking2.DescribeClusterRankingModelMastersRequest()
.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('ranking2')
api_result = client.describe_cluster_ranking_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('ranking2')
api_result_handler = client.describe_cluster_ranking_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;
```
---
### createClusterRankingModelMaster
클러스터 랭킹 모델 마스터 신규 생성
클러스터 타입, 스코어 범위, 정렬 순서, 합산 모드, 랭킹 보상, 보상 계산 인덱스, 참가/접근 기간 이벤트 설정을 가진 새로운 클러스터 랭킹 모델 마스터를 생성합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| name | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| clusterType | 문자열 열거형
enum {
"Raw",
"Gs2Guild::Guild",
"Gs2Matchmaking::SeasonGathering"
}
| | ✓| | | 클러스터 타입
랭킹의 세그멘테이션에 사용하는 그룹(클러스터)의 종류를 정의합니다. "Raw"는 소속 검증 없이 임의의 클러스터 이름을 지정할 수 있으며, "Gs2Guild::Guild"는 GS2-Guild 길드에 대한 소속을 검증하고, "Gs2Matchmaking::SeasonGathering"은 GS2-Matchmaking 시즌 개더링에 대한 소속을 검증합니다.Raw: 검증 없음 / Gs2Guild::Guild: GS2-Guild 길드 / Gs2Matchmaking::SeasonGathering: GS2-Matchmaking 시즌 개더링 / |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 최소 점수
허용되는 점수의 최소값입니다. 이 값보다 낮은 점수는 등록 시 거부됩니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 최대 점수
허용되는 점수의 최대값입니다. 이 값을 초과하는 점수는 등록 시 거부됩니다. |
| sum | bool | | | false | | 점수 합산
활성화하면 등록된 모든 점수가 합산되어 합계값으로 랭킹이 결정됩니다. 비활성화된 경우 최고 점수만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓| | | 정렬 방향
랭킹 점수의 정렬 방향입니다. 점수가 낮을수록 상위인 경우 "오름차순", 점수가 높을수록 상위인 경우 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| rankingRewards | [List<RankingReward>](#rankingreward) | {entryPeriodEventId} != null | | [] | 0 ~ 100 items | 랭킹 보상 목록
각 시즌 종료 시의 랭킹 순위에 따라 지급되는 보상 목록입니다. 스코어 등록 가능 기간 이벤트가 설정되어 있는 경우에만 이용할 수 있습니다. |
| rewardCalculationIndex | 문자열 열거형
enum {
"rank",
"index"
}
| | | "rank" | | 보상 계산 인덱스
보상을 플레이어에게 대응시키는 방법을 결정합니다. "순위 기반"은 1부터 시작하는 랭킹 순위(동점 스코어는 동일 순위), "인덱스 기반"은 0부터 시작하는 고유한 정렬 위치(동일 순위 없음)를 사용합니다.rank: 순위 기반으로 보상 결정 / index: 인덱스 기반으로 보상 결정 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 시즌제 랭킹을 구현할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과의 열람과 보상 수령이 가능한 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingModelMaster](#clusterrankingmodelmaster) | 생성한 클러스터 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CreateClusterRankingModelMaster(
&ranking2.CreateClusterRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("cluster-0001"),
Description: nil,
Metadata: nil,
ClusterType: pointy.String("Raw"),
MinimumValue: nil,
MaximumValue: nil,
Sum: nil,
OrderDirection: pointy.String("asc"),
RankingRewards: nil,
RewardCalculationIndex: nil,
EntryPeriodEventId: nil,
AccessPeriodEventId: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CreateClusterRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->createClusterRankingModelMaster(
(new CreateClusterRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withName("cluster-0001")
->withDescription(null)
->withMetadata(null)
->withClusterType("Raw")
->withMinimumValue(null)
->withMaximumValue(null)
->withSum(null)
->withOrderDirection("asc")
->withRankingRewards(null)
->withRewardCalculationIndex(null)
->withEntryPeriodEventId(null)
->withAccessPeriodEventId(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CreateClusterRankingModelMasterRequest;
import io.gs2.ranking2.result.CreateClusterRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
CreateClusterRankingModelMasterResult result = client.createClusterRankingModelMaster(
new CreateClusterRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("cluster-0001")
.withDescription(null)
.withMetadata(null)
.withClusterType("Raw")
.withMinimumValue(null)
.withMaximumValue(null)
.withSum(null)
.withOrderDirection("asc")
.withRankingRewards(null)
.withRewardCalculationIndex(null)
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
ClusterRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateClusterRankingModelMaster(
new Gs2.Gs2Ranking2.Request.CreateClusterRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("cluster-0001")
.WithDescription(null)
.WithMetadata(null)
.WithClusterType("Raw")
.WithMinimumValue(null)
.WithMaximumValue(null)
.WithSum(null)
.WithOrderDirection("asc")
.WithRankingRewards(null)
.WithRewardCalculationIndex(null)
.WithEntryPeriodEventId(null)
.WithAccessPeriodEventId(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.createClusterRankingModelMaster(
new Gs2Ranking2.CreateClusterRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("cluster-0001")
.withDescription(null)
.withMetadata(null)
.withClusterType("Raw")
.withMinimumValue(null)
.withMaximumValue(null)
.withSum(null)
.withOrderDirection("asc")
.withRankingRewards(null)
.withRewardCalculationIndex(null)
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.create_cluster_ranking_model_master(
ranking2.CreateClusterRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('cluster-0001')
.with_description(None)
.with_metadata(None)
.with_cluster_type('Raw')
.with_minimum_value(None)
.with_maximum_value(None)
.with_sum(None)
.with_order_direction('asc')
.with_ranking_rewards(None)
.with_reward_calculation_index(None)
.with_entry_period_event_id(None)
.with_access_period_event_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.create_cluster_ranking_model_master({
namespaceName="namespace-0001",
name="cluster-0001",
description=nil,
metadata=nil,
clusterType="Raw",
minimumValue=nil,
maximumValue=nil,
sum=nil,
orderDirection="asc",
rankingRewards=nil,
rewardCalculationIndex=nil,
entryPeriodEventId=nil,
accessPeriodEventId=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('ranking2')
api_result_handler = client.create_cluster_ranking_model_master_async({
namespaceName="namespace-0001",
name="cluster-0001",
description=nil,
metadata=nil,
clusterType="Raw",
minimumValue=nil,
maximumValue=nil,
sum=nil,
orderDirection="asc",
rankingRewards=nil,
rewardCalculationIndex=nil,
entryPeriodEventId=nil,
accessPeriodEventId=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;
```
---
### getClusterRankingModelMaster
클러스터 랭킹 모델 마스터 조회
지정된 클러스터 랭킹 모델 마스터를 조회합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingModelMaster](#clusterrankingmodelmaster) | 클러스터 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetClusterRankingModelMaster(
&ranking2.GetClusterRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("cluster-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetClusterRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getClusterRankingModelMaster(
(new GetClusterRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withRankingName("cluster-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetClusterRankingModelMasterRequest;
import io.gs2.ranking2.result.GetClusterRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetClusterRankingModelMasterResult result = client.getClusterRankingModelMaster(
new GetClusterRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("cluster-0001")
);
ClusterRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetClusterRankingModelMaster(
new Gs2.Gs2Ranking2.Request.GetClusterRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("cluster-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getClusterRankingModelMaster(
new Gs2Ranking2.GetClusterRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("cluster-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_cluster_ranking_model_master(
ranking2.GetClusterRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('cluster-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_cluster_ranking_model_master({
namespaceName="namespace-0001",
rankingName="cluster-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('ranking2')
api_result_handler = client.get_cluster_ranking_model_master_async({
namespaceName="namespace-0001",
rankingName="cluster-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;
```
---
### updateClusterRankingModelMaster
클러스터 랭킹 모델 마스터 갱신
지정된 클러스터 랭킹 모델 마스터의 클러스터 타입, 스코어 범위, 정렬 순서, 합산 모드, 랭킹 보상, 보상 계산 인덱스, 참가/접근 기간 이벤트 설정을 갱신합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| clusterType | 문자열 열거형
enum {
"Raw",
"Gs2Guild::Guild",
"Gs2Matchmaking::SeasonGathering"
}
| | ✓| | | 클러스터 타입
랭킹의 세그멘테이션에 사용하는 그룹(클러스터)의 종류를 정의합니다. "Raw"는 소속 검증 없이 임의의 클러스터 이름을 지정할 수 있으며, "Gs2Guild::Guild"는 GS2-Guild 길드에 대한 소속을 검증하고, "Gs2Matchmaking::SeasonGathering"은 GS2-Matchmaking 시즌 개더링에 대한 소속을 검증합니다.Raw: 검증 없음 / Gs2Guild::Guild: GS2-Guild 길드 / Gs2Matchmaking::SeasonGathering: GS2-Matchmaking 시즌 개더링 / |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 최소 점수
허용되는 점수의 최소값입니다. 이 값보다 낮은 점수는 등록 시 거부됩니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 최대 점수
허용되는 점수의 최대값입니다. 이 값을 초과하는 점수는 등록 시 거부됩니다. |
| sum | bool | | | false | | 점수 합산
활성화하면 등록된 모든 점수가 합산되어 합계값으로 랭킹이 결정됩니다. 비활성화된 경우 최고 점수만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓| | | 정렬 방향
랭킹 점수의 정렬 방향입니다. 점수가 낮을수록 상위인 경우 "오름차순", 점수가 높을수록 상위인 경우 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| rankingRewards | [List<RankingReward>](#rankingreward) | {entryPeriodEventId} != null | | [] | 0 ~ 100 items | 랭킹 보상 목록
각 시즌 종료 시의 랭킹 순위에 따라 지급되는 보상 목록입니다. 스코어 등록 가능 기간 이벤트가 설정되어 있는 경우에만 이용할 수 있습니다. |
| rewardCalculationIndex | 문자열 열거형
enum {
"rank",
"index"
}
| | | "rank" | | 보상 계산 인덱스
보상을 플레이어에게 대응시키는 방법을 결정합니다. "순위 기반"은 1부터 시작하는 랭킹 순위(동점 스코어는 동일 순위), "인덱스 기반"은 0부터 시작하는 고유한 정렬 위치(동일 순위 없음)를 사용합니다.rank: 순위 기반으로 보상 결정 / index: 인덱스 기반으로 보상 결정 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 시즌제 랭킹을 구현할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과의 열람과 보상 수령이 가능한 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingModelMaster](#clusterrankingmodelmaster) | 갱신한 클러스터 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.UpdateClusterRankingModelMaster(
&ranking2.UpdateClusterRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("cluster-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("CATEGORY_0001"),
ClusterType: pointy.String("Gs2Guild::Guild"),
MinimumValue: pointy.Int64(100),
MaximumValue: pointy.Int64(10000),
Sum: nil,
OrderDirection: pointy.String("desc"),
RankingRewards: nil,
RewardCalculationIndex: nil,
EntryPeriodEventId: nil,
AccessPeriodEventId: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\UpdateClusterRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->updateClusterRankingModelMaster(
(new UpdateClusterRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withRankingName("cluster-0001")
->withDescription("description1")
->withMetadata("CATEGORY_0001")
->withClusterType("Gs2Guild::Guild")
->withMinimumValue(100)
->withMaximumValue(10000)
->withSum(null)
->withOrderDirection("desc")
->withRankingRewards(null)
->withRewardCalculationIndex(null)
->withEntryPeriodEventId(null)
->withAccessPeriodEventId(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.UpdateClusterRankingModelMasterRequest;
import io.gs2.ranking2.result.UpdateClusterRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
UpdateClusterRankingModelMasterResult result = client.updateClusterRankingModelMaster(
new UpdateClusterRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("cluster-0001")
.withDescription("description1")
.withMetadata("CATEGORY_0001")
.withClusterType("Gs2Guild::Guild")
.withMinimumValue(100L)
.withMaximumValue(10000L)
.withSum(null)
.withOrderDirection("desc")
.withRankingRewards(null)
.withRewardCalculationIndex(null)
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
ClusterRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateClusterRankingModelMaster(
new Gs2.Gs2Ranking2.Request.UpdateClusterRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("cluster-0001")
.WithDescription("description1")
.WithMetadata("CATEGORY_0001")
.WithClusterType("Gs2Guild::Guild")
.WithMinimumValue(100L)
.WithMaximumValue(10000L)
.WithSum(null)
.WithOrderDirection("desc")
.WithRankingRewards(null)
.WithRewardCalculationIndex(null)
.WithEntryPeriodEventId(null)
.WithAccessPeriodEventId(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.updateClusterRankingModelMaster(
new Gs2Ranking2.UpdateClusterRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("cluster-0001")
.withDescription("description1")
.withMetadata("CATEGORY_0001")
.withClusterType("Gs2Guild::Guild")
.withMinimumValue(100)
.withMaximumValue(10000)
.withSum(null)
.withOrderDirection("desc")
.withRankingRewards(null)
.withRewardCalculationIndex(null)
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.update_cluster_ranking_model_master(
ranking2.UpdateClusterRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('cluster-0001')
.with_description('description1')
.with_metadata('CATEGORY_0001')
.with_cluster_type('Gs2Guild::Guild')
.with_minimum_value(100)
.with_maximum_value(10000)
.with_sum(None)
.with_order_direction('desc')
.with_ranking_rewards(None)
.with_reward_calculation_index(None)
.with_entry_period_event_id(None)
.with_access_period_event_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.update_cluster_ranking_model_master({
namespaceName="namespace-0001",
rankingName="cluster-0001",
description="description1",
metadata="CATEGORY_0001",
clusterType="Gs2Guild::Guild",
minimumValue=100,
maximumValue=10000,
sum=nil,
orderDirection="desc",
rankingRewards=nil,
rewardCalculationIndex=nil,
entryPeriodEventId=nil,
accessPeriodEventId=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('ranking2')
api_result_handler = client.update_cluster_ranking_model_master_async({
namespaceName="namespace-0001",
rankingName="cluster-0001",
description="description1",
metadata="CATEGORY_0001",
clusterType="Gs2Guild::Guild",
minimumValue=100,
maximumValue=10000,
sum=nil,
orderDirection="desc",
rankingRewards=nil,
rewardCalculationIndex=nil,
entryPeriodEventId=nil,
accessPeriodEventId=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;
```
---
### deleteClusterRankingModelMaster
클러스터 랭킹 모델 마스터 삭제
지정된 클러스터 랭킹 모델 마스터를 삭제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 클러스터 랭킹 모델 이름
클러스터 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [ClusterRankingModelMaster](#clusterrankingmodelmaster) | 삭제한 클러스터 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteClusterRankingModelMaster(
&ranking2.DeleteClusterRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("cluster-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteClusterRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->deleteClusterRankingModelMaster(
(new DeleteClusterRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withRankingName("cluster-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteClusterRankingModelMasterRequest;
import io.gs2.ranking2.result.DeleteClusterRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DeleteClusterRankingModelMasterResult result = client.deleteClusterRankingModelMaster(
new DeleteClusterRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("cluster-0001")
);
ClusterRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteClusterRankingModelMaster(
new Gs2.Gs2Ranking2.Request.DeleteClusterRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("cluster-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteClusterRankingModelMaster(
new Gs2Ranking2.DeleteClusterRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("cluster-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_cluster_ranking_model_master(
ranking2.DeleteClusterRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('cluster-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.delete_cluster_ranking_model_master({
namespaceName="namespace-0001",
rankingName="cluster-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('ranking2')
api_result_handler = client.delete_cluster_ranking_model_master_async({
namespaceName="namespace-0001",
rankingName="cluster-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;
```
---
### describeSubscribeRankingModelMasters
구독 랭킹 모델 마스터 목록 조회
구독 랭킹 모델 마스터의 페이지네이션 목록을 조회합니다. 이름의 접두사로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| namePrefix | string | | | | ~ 64자 | 구독 랭킹 모델 이름의 필터 접두사 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SubscribeRankingModelMaster>](#subscriberankingmodelmaster) | 구독 랭킹 모델 마스터 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DescribeSubscribeRankingModelMasters(
&ranking2.DescribeSubscribeRankingModelMastersRequest {
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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DescribeSubscribeRankingModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->describeSubscribeRankingModelMasters(
(new DescribeSubscribeRankingModelMastersRequest())
->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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DescribeSubscribeRankingModelMastersRequest;
import io.gs2.ranking2.result.DescribeSubscribeRankingModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DescribeSubscribeRankingModelMastersResult result = client.describeSubscribeRankingModelMasters(
new DescribeSubscribeRankingModelMastersRequest()
.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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribeRankingModelMasters(
new Gs2.Gs2Ranking2.Request.DescribeSubscribeRankingModelMastersRequest()
.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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.describeSubscribeRankingModelMasters(
new Gs2Ranking2.DescribeSubscribeRankingModelMastersRequest()
.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 ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.describe_subscribe_ranking_model_masters(
ranking2.DescribeSubscribeRankingModelMastersRequest()
.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('ranking2')
api_result = client.describe_subscribe_ranking_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('ranking2')
api_result_handler = client.describe_subscribe_ranking_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;
```
---
### createSubscribeRankingModelMaster
구독 랭킹 모델 마스터 신규 생성
스코어 범위, 정렬 순서, 합계 모드, 엔트리/액세스 기간 이벤트 설정을 가진 새로운 구독 랭킹 모델 마스터를 생성합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| name | string | | ✓| | ~ 128자 | 구독 랭킹 모델명
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈), _(밑줄), .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 최소 점수
허용되는 점수의 최소값입니다. 이 값보다 낮은 점수는 등록 시 거부됩니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 최대 점수
허용되는 점수의 최대값입니다. 이 값을 초과하는 점수는 등록 시 거부됩니다. |
| sum | bool | | | false | | 점수 합산
활성화하면 등록된 모든 점수가 합산되어 합계값으로 랭킹이 결정됩니다. 비활성화된 경우 최고 점수만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓| | | 정렬 방향
랭킹 점수의 정렬 방향입니다. 점수가 낮을수록 상위인 경우 "오름차순", 점수가 높을수록 상위인 경우 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 시즌제 랭킹을 구현할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과를 열람할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingModelMaster](#subscriberankingmodelmaster) | 생성한 구독 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.CreateSubscribeRankingModelMaster(
&ranking2.CreateSubscribeRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("subscribe-0001"),
Description: nil,
Metadata: nil,
MinimumValue: nil,
MaximumValue: nil,
Sum: nil,
OrderDirection: pointy.String("asc"),
EntryPeriodEventId: nil,
AccessPeriodEventId: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\CreateSubscribeRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->createSubscribeRankingModelMaster(
(new CreateSubscribeRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withName("subscribe-0001")
->withDescription(null)
->withMetadata(null)
->withMinimumValue(null)
->withMaximumValue(null)
->withSum(null)
->withOrderDirection("asc")
->withEntryPeriodEventId(null)
->withAccessPeriodEventId(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.CreateSubscribeRankingModelMasterRequest;
import io.gs2.ranking2.result.CreateSubscribeRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
CreateSubscribeRankingModelMasterResult result = client.createSubscribeRankingModelMaster(
new CreateSubscribeRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("subscribe-0001")
.withDescription(null)
.withMetadata(null)
.withMinimumValue(null)
.withMaximumValue(null)
.withSum(null)
.withOrderDirection("asc")
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
SubscribeRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateSubscribeRankingModelMaster(
new Gs2.Gs2Ranking2.Request.CreateSubscribeRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("subscribe-0001")
.WithDescription(null)
.WithMetadata(null)
.WithMinimumValue(null)
.WithMaximumValue(null)
.WithSum(null)
.WithOrderDirection("asc")
.WithEntryPeriodEventId(null)
.WithAccessPeriodEventId(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.createSubscribeRankingModelMaster(
new Gs2Ranking2.CreateSubscribeRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("subscribe-0001")
.withDescription(null)
.withMetadata(null)
.withMinimumValue(null)
.withMaximumValue(null)
.withSum(null)
.withOrderDirection("asc")
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.create_subscribe_ranking_model_master(
ranking2.CreateSubscribeRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('subscribe-0001')
.with_description(None)
.with_metadata(None)
.with_minimum_value(None)
.with_maximum_value(None)
.with_sum(None)
.with_order_direction('asc')
.with_entry_period_event_id(None)
.with_access_period_event_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.create_subscribe_ranking_model_master({
namespaceName="namespace-0001",
name="subscribe-0001",
description=nil,
metadata=nil,
minimumValue=nil,
maximumValue=nil,
sum=nil,
orderDirection="asc",
entryPeriodEventId=nil,
accessPeriodEventId=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('ranking2')
api_result_handler = client.create_subscribe_ranking_model_master_async({
namespaceName="namespace-0001",
name="subscribe-0001",
description=nil,
metadata=nil,
minimumValue=nil,
maximumValue=nil,
sum=nil,
orderDirection="asc",
entryPeriodEventId=nil,
accessPeriodEventId=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;
```
---
### getSubscribeRankingModelMaster
구독 랭킹 모델 마스터 조회
지정된 구독 랭킹 모델 마스터를 조회합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델명
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈), _(밑줄), .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingModelMaster](#subscriberankingmodelmaster) | 구독 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.GetSubscribeRankingModelMaster(
&ranking2.GetSubscribeRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("subscribe-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\GetSubscribeRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->getSubscribeRankingModelMaster(
(new GetSubscribeRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withRankingName("subscribe-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.GetSubscribeRankingModelMasterRequest;
import io.gs2.ranking2.result.GetSubscribeRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
GetSubscribeRankingModelMasterResult result = client.getSubscribeRankingModelMaster(
new GetSubscribeRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("subscribe-0001")
);
SubscribeRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribeRankingModelMaster(
new Gs2.Gs2Ranking2.Request.GetSubscribeRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("subscribe-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.getSubscribeRankingModelMaster(
new Gs2Ranking2.GetSubscribeRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("subscribe-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.get_subscribe_ranking_model_master(
ranking2.GetSubscribeRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('subscribe-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.get_subscribe_ranking_model_master({
namespaceName="namespace-0001",
rankingName="subscribe-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('ranking2')
api_result_handler = client.get_subscribe_ranking_model_master_async({
namespaceName="namespace-0001",
rankingName="subscribe-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;
```
---
### updateSubscribeRankingModelMaster
구독 랭킹 모델 마스터 업데이트
지정된 구독 랭킹 모델 마스터의 스코어 범위, 정렬 순서, 합계 모드, 엔트리/액세스 기간 이벤트 설정을 업데이트합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델명
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈), _(밑줄), .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 최소 점수
허용되는 점수의 최소값입니다. 이 값보다 낮은 점수는 등록 시 거부됩니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 최대 점수
허용되는 점수의 최대값입니다. 이 값을 초과하는 점수는 등록 시 거부됩니다. |
| sum | bool | | | false | | 점수 합산
활성화하면 등록된 모든 점수가 합산되어 합계값으로 랭킹이 결정됩니다. 비활성화된 경우 최고 점수만 랭킹에 사용됩니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓| | | 정렬 방향
랭킹 점수의 정렬 방향입니다. 점수가 낮을수록 상위인 경우 "오름차순", 점수가 높을수록 상위인 경우 "내림차순"을 사용합니다.asc: 오름차순 / desc: 내림차순 / |
| entryPeriodEventId | string | | | | ~ 1024자 | 스코어 등록 가능 기간 이벤트 GRN
스코어를 등록할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. 반복 이벤트와 연결하면 시즌제 랭킹을 구현할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 랭킹 데이터 접근 가능 기간 이벤트 GRN
랭킹 결과를 열람할 수 있는 기간을 정의하는 GS2-Schedule의 이벤트 GRN입니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingModelMaster](#subscriberankingmodelmaster) | 업데이트한 구독 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.UpdateSubscribeRankingModelMaster(
&ranking2.UpdateSubscribeRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("subscribe-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("CATEGORY_0001"),
MinimumValue: pointy.Int64(100),
MaximumValue: pointy.Int64(10000),
Sum: nil,
OrderDirection: pointy.String("desc"),
EntryPeriodEventId: nil,
AccessPeriodEventId: 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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\UpdateSubscribeRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->updateSubscribeRankingModelMaster(
(new UpdateSubscribeRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withRankingName("subscribe-0001")
->withDescription("description1")
->withMetadata("CATEGORY_0001")
->withMinimumValue(100)
->withMaximumValue(10000)
->withSum(null)
->withOrderDirection("desc")
->withEntryPeriodEventId(null)
->withAccessPeriodEventId(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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.UpdateSubscribeRankingModelMasterRequest;
import io.gs2.ranking2.result.UpdateSubscribeRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
UpdateSubscribeRankingModelMasterResult result = client.updateSubscribeRankingModelMaster(
new UpdateSubscribeRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("subscribe-0001")
.withDescription("description1")
.withMetadata("CATEGORY_0001")
.withMinimumValue(100L)
.withMaximumValue(10000L)
.withSum(null)
.withOrderDirection("desc")
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
SubscribeRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateSubscribeRankingModelMaster(
new Gs2.Gs2Ranking2.Request.UpdateSubscribeRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("subscribe-0001")
.WithDescription("description1")
.WithMetadata("CATEGORY_0001")
.WithMinimumValue(100L)
.WithMaximumValue(10000L)
.WithSum(null)
.WithOrderDirection("desc")
.WithEntryPeriodEventId(null)
.WithAccessPeriodEventId(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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.updateSubscribeRankingModelMaster(
new Gs2Ranking2.UpdateSubscribeRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("subscribe-0001")
.withDescription("description1")
.withMetadata("CATEGORY_0001")
.withMinimumValue(100)
.withMaximumValue(10000)
.withSum(null)
.withOrderDirection("desc")
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.update_subscribe_ranking_model_master(
ranking2.UpdateSubscribeRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('subscribe-0001')
.with_description('description1')
.with_metadata('CATEGORY_0001')
.with_minimum_value(100)
.with_maximum_value(10000)
.with_sum(None)
.with_order_direction('desc')
.with_entry_period_event_id(None)
.with_access_period_event_id(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.update_subscribe_ranking_model_master({
namespaceName="namespace-0001",
rankingName="subscribe-0001",
description="description1",
metadata="CATEGORY_0001",
minimumValue=100,
maximumValue=10000,
sum=nil,
orderDirection="desc",
entryPeriodEventId=nil,
accessPeriodEventId=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('ranking2')
api_result_handler = client.update_subscribe_ranking_model_master_async({
namespaceName="namespace-0001",
rankingName="subscribe-0001",
description="description1",
metadata="CATEGORY_0001",
minimumValue=100,
maximumValue=10000,
sum=nil,
orderDirection="desc",
entryPeriodEventId=nil,
accessPeriodEventId=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;
```
---
### deleteSubscribeRankingModelMaster
구독 랭킹 모델 마스터 삭제
지정된 구독 랭킹 모델 마스터를 삭제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| rankingName | string | | ✓| | ~ 128자 | 구독 랭킹 모델명
구독 랭킹 모델 고유의 이름입니다. 영숫자 및 -(하이픈), _(밑줄), .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [SubscribeRankingModelMaster](#subscriberankingmodelmaster) | 삭제한 구독 랭킹 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking2"
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 := ranking2.Gs2Ranking2RestClient{
Session: &session,
}
result, err := client.DeleteSubscribeRankingModelMaster(
&ranking2.DeleteSubscribeRankingModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
RankingName: pointy.String("subscribe-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\Ranking2\Gs2Ranking2RestClient;
use Gs2\Ranking2\Request\DeleteSubscribeRankingModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2Ranking2RestClient(
$session
);
try {
$result = $client->deleteSubscribeRankingModelMaster(
(new DeleteSubscribeRankingModelMasterRequest())
->withNamespaceName("namespace-0001")
->withRankingName("subscribe-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.ranking2.rest.Gs2Ranking2RestClient;
import io.gs2.ranking2.request.DeleteSubscribeRankingModelMasterRequest;
import io.gs2.ranking2.result.DeleteSubscribeRankingModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2Ranking2RestClient client = new Gs2Ranking2RestClient(session);
try {
DeleteSubscribeRankingModelMasterResult result = client.deleteSubscribeRankingModelMaster(
new DeleteSubscribeRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("subscribe-0001")
);
SubscribeRankingModelMaster 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 Gs2Ranking2RestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteSubscribeRankingModelMaster(
new Gs2.Gs2Ranking2.Request.DeleteSubscribeRankingModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithRankingName("subscribe-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 Gs2Ranking2 from '@/gs2/ranking2';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking2.Gs2Ranking2RestClient(session);
try {
const result = await client.deleteSubscribeRankingModelMaster(
new Gs2Ranking2.DeleteSubscribeRankingModelMasterRequest()
.withNamespaceName("namespace-0001")
.withRankingName("subscribe-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking2
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking2.Gs2Ranking2RestClient(session)
try:
result = client.delete_subscribe_ranking_model_master(
ranking2.DeleteSubscribeRankingModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_ranking_name('subscribe-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking2')
api_result = client.delete_subscribe_ranking_model_master({
namespaceName="namespace-0001",
rankingName="subscribe-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('ranking2')
api_result_handler = client.delete_subscribe_ranking_model_master_async({
namespaceName="namespace-0001",
rankingName="subscribe-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;
```
---