> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Ranking SDK API 레퍼런스
각종 프로그래밍 언어용 GS2-Ranking SDK의 모델 사양과 API 레퍼런스
## 모델
### Namespace
네임스페이스
네임스페이스는 하나의 프로젝트 내에서 동일한 서비스를 서로 다른 용도로 여러 개 이용하기 위한 엔티티입니다.
GS2의 각 서비스는 네임스페이스 단위로 관리됩니다. 네임스페이스가 다르면 동일한 서비스라도 완전히 독립된 데이터 공간으로 취급됩니다.
따라서 각 서비스의 이용을 시작하려면 먼저 네임스페이스를 생성해야 합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024자 | 네임스페이스 GRN
※ 서버가 자동으로 설정 |
| name | string | | ✓ | | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| transactionSetting | [TransactionSetting](#transactionsetting) | | | | | 트랜잭션 설정
랭킹 조작 시 트랜잭션의 처리 방법을 제어하는 설정입니다. |
| lastCalculatedAts | [List<CalculatedAt>](#calculatedat) | | | [] | 0 ~ 1000 items | 최종 집계일시 리스트
각 카테고리의 글로벌 랭킹이 마지막으로 집계된 일시를 기록하는 타임스탬프 리스트입니다.
카테고리별로 1개의 엔트리가 유지되며, 재집계가 완료되면 해당 엔트리가 업데이트됩니다(신규 카테고리의 경우 새로운 엔트리가 추가됩니다). |
| logSetting | [LogSetting](#logsetting) | | | | | 로그 출력 설정
랭킹 관련 조작 로그를 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에서 업데이트
---
### Subscribe
구독
스코프 랭킹의 구독 상태를 보유하며, 플레이어가 어떤 사용자의 스코어를 팔로우하고 있는지를 추적합니다.
스코프 랭킹 모드에서는 각 플레이어가 구독한 사용자에 기반한 개인화된 리더보드를 참조합니다.
targetUserIds는 플레이어가 추적하고 싶은 사용자의 목록이며, subscribedUserIds는 확인된(상호 또는 승인된) 구독을 나타냅니다.
사용자별·카테고리별로 최대 10,000건의 구독이 가능합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| subscribeId | string | | ※ | | ~ 1024자 | 구독 GRN
※ 서버가 자동으로 설정 |
| categoryName | string | | ✓ | | ~ 128자 | 카테고리명 |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| targetUserIds | List<string> | | | [] | 0 ~ 10000 items | 구독 대상 사용자 ID 목록
스코프 랭킹에서 플레이어가 추적하고자 하는 사용자 ID 목록입니다.
이 목록에 사용자 ID를 추가하면 해당 사용자의 점수가 플레이어의 개인화된 리더보드에 포함됩니다. 최대 10,000건. |
| subscribedUserIds | List<string> | | | [] | 0 ~ 10000 items | 구독자 사용자 ID 목록
이 플레이어의 점수를 구독(팔로우)하고 있는 사용자 ID 목록입니다.
구독 관계의 역방향을 나타내며, 이 사용자들의 스코프 랭킹에는 이 플레이어의 점수가 표시됩니다. 최대 10,000건. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
---
### Score
스코어
게임 플레이어별·카테고리별로 등록된 스코어를 보유하는 엔티티입니다.
각 스코어 엔트리는 고유 ID로 식별되며, 카테고리 및 스코어 등록 사용자와 연결됩니다.
합산 모드에서는 새로운 스코어가 별도의 엔트리를 생성하는 대신 AddScore 조작을 통해 기존 합계에 가산됩니다.
카테고리의 최소값·최대값 범위를 벗어나는 스코어는 등록 시 거부됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| scoreId | string | | ※ | | ~ 1024자 | 스코어 GRN
※ 서버가 자동으로 설정 |
| categoryName | string | | ✓ | | ~ 128자 | 카테고리명 |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| uniqueId | string | | ✓ | UUID | ~ 36자 | 고유 ID
이 스코어 엔트리를 고유하게 식별하는 UUID입니다.
생성 시 자동으로 생성됩니다. uniqueByUserId가 비활성화된 경우, 동일 사용자의 동일 카테고리 내 여러 스코어 엔트리를 구분하기 위해 사용됩니다. |
| scorerUserId | string | | ✓ | | ~ 128자 | 사용자ID |
| score | long | | ✓ | | 0 ~ 9223372036854775805 | 스코어
플레이어가 등록한 스코어 값입니다.
카테고리에 설정된 최소값·최대값 범위 내여야 합니다. 합산 모드에서는 AddScore 조작을 통해 이 값을 증가시킬 수 있습니다. |
| metadata | string | | | | ~ 512자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeScores - 스코어 목록 취득
describeScoresByUserId - 사용자 ID를 지정하여 스코어 목록 취득
getScore - 스코어 취득
getScoreByUserId - 사용자 ID를 지정하여 스코어 취득
putScore - 스코어 등록
putScoreByUserId - 사용자 ID를 지정하여 스코어 등록
---
### Ranking
랭킹
랭킹 리더보드의 한 항목을 나타내며, 사용자의 순위, 점수 및 관련 메타데이터를 포함합니다.
글로벌 랭킹(모든 플레이어가 공유 보드에서 배치 집계로 경쟁)과 스코프 랭킹(구독한 플레이어를 기반으로 한 사용자별 보드에서 실시간 반영)의 두 종류가 있습니다.
랭킹은 카테고리에 설정된 정렬 방향으로 정렬되며, 동일 점수인 항목은 동일한 순위를 공유하면서도 서로 다른 인덱스를 유지합니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| rank | long | | ✓ | | 1 ~ 9223372036854775805 | 순위
이 항목의 랭킹 순위(1부터 시작)입니다.
동일 점수인 항목은 동일한 순위 값을 공유합니다. 예를 들어 두 사용자가 1위로 동점인 경우, 둘 다 순위 1이 되고 다음 항목은 순위 3이 됩니다. |
| index | long | | ✓ | | 0 ~ 9223372036854775805 | 인덱스
랭킹 목록 내의 0부터 시작하는 순차 인덱스입니다.
rank 와 달리, 여러 항목이 동일 점수를 공유하더라도 인덱스는 항상 유일하며 연속됩니다. 페이지네이션이나 범위 기반 쿼리에 사용됩니다. |
| categoryName | string | | ✓ | | ~ 128자 | 카테고리 모델 이름 |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| score | long | | ✓ | | 0 ~ 9223372036854775805 | 스코어
이 랭킹 엔트리의 스코어 값입니다.
합산 모드의 경우, 등록된 모든 스코어의 누적 합계입니다. 랭킹 정렬 순서에 사용되는 값은 카테고리의 orderDirection 설정에 따라 달라집니다. |
| metadata | string | | | | ~ 512자 | 메타데이터
이 랭킹 엔트리에 연결된 임의의 메타데이터입니다.
스코어 등록 시 설정되며, 랭킹 결과와 함께 반환됩니다. 최대 512자. |
| createdAt | long | | ✓ | | | 작성일시
UNIX 시간·밀리초
※ 서버 측에서 자동으로 설정 |
**관련 메서드:**
describeRankings - 랭킹 취득
describeRankingssByUserId - 사용자 ID를 지정하여 랭킹 취득
describeNearRankings - 지정한 스코어 부근의 랭킹 취득
getRanking - 랭킹 취득
getRankingByUserId - 사용자 ID를 지정하여 랭킹 취득
---
### SubscribeUser
구독 사용자
스코프 랭킹 카테고리 내 개별 구독 관계를 나타냅니다.
각 항목은 상위 사용자가 지정된 카테고리에서 대상 사용자의 점수를 구독(팔로우)하고 있음을 나타냅니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| subscribeUserId | string | | ※ | | ~ 1024자 | 구독 대상 GRN
※ 서버가 자동으로 설정 |
| categoryName | string | | ✓ | | ~ 128자 | 카테고리 모델 이름 |
| userId | string | | ✓ | | ~ 128자 | 사용자ID |
| targetUserId | string | | ✓ | | ~ 128자 | 구독 대상 사용자 ID
구독 대상 플레이어의 사용자 ID입니다.
이 사용자의 점수는 구독한 사용자의 지정된 카테고리에 대한 스코프 랭킹에 표시됩니다. |
**관련 메서드:**
subscribe - 대상 사용자 구독
subscribeByUserId - 사용자 ID를 지정하여 대상 사용자 구독
getSubscribe - 구독 대상 사용자 정보 취득
getSubscribeByUserId - 사용자 ID를 지정하여 구독 정보 취득
unsubscribe - 대상 사용자의 구독 해제
unsubscribeByUserId - 사용자 ID를 지정하여 대상 사용자의 구독 해제
describeSubscribesByCategoryName - 구독 중인 사용자의 사용자 ID 목록 취득
describeSubscribesByCategoryNameAndUserId - 사용자 ID를 지정하여 해당 사용자가 구독하고 있는 사용자 목록 취득
---
### CategoryModel
카테고리 모델
카테고리마다 서로 다른 랭킹을 생성할 수 있습니다.
카테고리에는 등록 가능한 스코어의 최소값·최대값을 설정할 수 있으며, 해당 범위를 벗어나는 스코어는 폐기됩니다.
랭킹을 집계할 때 스코어가 작은 것을 상위(오름차순)로 할지, 큰 것을 상위(내림차순)로 할지를 설정할 수 있습니다.
랭킹의 종류로 `글로벌`과 `스코프`를 선택할 수 있습니다.
글로벌은 모든 플레이어가 동일한 결과를 참조하는 것이며, 스코프는 친구 내 랭킹이나 길드 내 랭킹처럼 게임 플레이어마다 결과가 다른 랭킹입니다.
글로벌 랭킹은 카테고리별로 랭킹 집계 간격을 15분~24시간으로 설정할 수 있습니다.
스코프 랭킹은 실시간으로 집계 결과가 반영됩니다.
랭킹 데이터에는 세대라는 설정이 있으며, 세대를 변경함으로써 등록된 스코어를 리셋할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| categoryModelId | 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"(내림차순)는 높은 점수를 상위로 하며, 포인트 기반이나 하이스코어 랭킹에 적합합니다.asc: 오름차순 / desc: 내림차순 / |
| scope | 문자열 열거형
enum {
"global",
"scoped"
}
| | ✓ | | | 랭킹 종류
이 카테고리의 랭킹 타입입니다.
"global" 은 모든 플레이어가 공유하는 단일 리더보드를 만들며, 설정된 간격으로 배치 집계됩니다.
"scoped" 는 구독한 플레이어(친구나 길드 멤버 등)를 기반으로 한 사용자별 리더보드를 만들며, 점수가 실시간으로 반영됩니다.global: 글로벌 / scoped: 스코프 / |
| globalRankingSetting | [GlobalRankingSetting](#globalrankingsetting) | {scope} == "global" | ✓※ | | | 글로벌 랭킹 설정
글로벌 랭킹 모드 전용 설정입니다. 집계 간격, 고정 시각, 점수의 유니크 여부, 세대 관리, 추가 기간 한정 스코프를 포함합니다.
scope 가 "global" 로 설정된 경우에만 적용됩니다.
※ scope이(가) "global" 이면 필수 |
| entryPeriodEventId | string | | | | ~ 1024자 | 점수 등록 기간 이벤트 ID
점수 등록을 받는 기간을 정의하는 GS2-Schedule 이벤트의 GRN입니다.
이 기간 외의 점수 등록 요청은 거부됩니다. 설정하지 않으면 점수는 언제든지 등록할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 접근 기간 이벤트 ID
랭킹 데이터를 열람할 수 있는 기간을 정의하는 GS2-Schedule 이벤트의 GRN입니다.
이 기간 외의 랭킹 조회 요청은 거부됩니다. 설정하지 않으면 랭킹은 언제든지 접근할 수 있습니다. |
**관련 메서드:**
describeCategoryModels - 카테고리 모델 목록 취득
getCategoryModel - 카테고리 모델 취득
---
### Scope
집계 스코프
글로벌 랭킹 모드에서의 추가적인 기간 한정 집계 스코프를 정의합니다.
일반적으로 글로벌 랭킹은 등록된 모든 스코어를 대상으로 집계됩니다.
스코프를 추가하면 지정한 일수 이내에 등록된 스코어만을 대상으로 하는 별도의 랭킹을 생성할 수 있으며, 전체 기간 랭킹과 함께 데일리·위클리·먼슬리 등의 리더보드를 구현할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128자 | 스코프 이름
카테고리 내에서 이 집계 스코프를 고유하게 식별하는 이름입니다.
여러 개의 기간 한정 랭킹 보드를 구분하기 위해 사용됩니다(예: "daily", "weekly"). 최대 128자. |
| targetDays | long | | ✓ | | 1 ~ 365 | 집계 대상 일수
집계 윈도우에 포함할 일수입니다.
현재 시각으로부터 이 일수 이내에 등록된 스코어만 스코프 랭킹의 대상이 됩니다. 범위: 1~365일. |
**관련 모델:**
CategoryModel - 카테고리 모델
GlobalRankingSetting - 글로벌 랭킹 설정
CategoryModelMaster - 카테고리 모델 마스터
---
### GlobalRankingSetting
글로벌 랭킹 설정
글로벌은 모든 플레이어가 동일한 결과를 참조하는 방식입니다.
랭킹 집계 간격은 15분~24시간으로 설정할 수 있습니다.
랭킹 데이터에는 세대라는 설정이 있으며, 세대를 변경함으로써 등록된 점수를 초기화할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| uniqueByUserId | bool | | | true | | 사용자 ID별 유니크
활성화하면 랭킹 내에서 사용자 ID별로 하나의 점수만 유지됩니다.
사용자가 새로운 점수를 등록하면 정렬 방향에 따라 더 나은 점수로 교체됩니다.
비활성화하면 동일 사용자로부터 여러 점수 항목이 허용되어 합산 모드나 다중 항목 경쟁이 가능해집니다. |
| calculateIntervalMinutes | int | | ✓ | | 15 ~ 1440 | 집계 간격(분)
연속되는 랭킹 재집계 사이의 간격(분)입니다.
시스템은 이 간격으로 등록된 모든 점수를 기반으로 글로벌 랭킹을 정기적으로 재집계합니다.
범위: 15~1440분(15분~24시간). |
| calculateFixedTiming | [FixedTiming](#fixedtiming) | | | | | 집계 시각 고정 설정
랭킹 재집계가 시작되는 하루 중 고정 시각(UTC)을 지정합니다.
설정하지 않으면 재집계는 정해지지 않은 기준 시각부터 일정 간격으로 실행됩니다.
이를 설정하면 매일 예측 가능하고 일관된 시각에 재집계가 이루어지도록 할 수 있습니다. |
| additionalScopes | [List<Scope>](#scope) | | | | 0 ~ 10 items | 추가 스코프 목록
추가적인 기간 한정 집계 스코프 목록입니다.
각 스코프는 지정한 일수 이내에 등록된 점수만을 대상으로 하는 별도의 랭킹을 정의합니다.
전체 기간의 글로벌 랭킹과 함께 데일리·위클리·먼슬리 등의 리더보드를 만들 수 있습니다. 최대 10건. |
| ignoreUserIds | List<string> | | | | 0 ~ 10000 items | 제외 사용자 ID 목록
랭킹 집계에서 점수를 제외할 사용자 ID 목록입니다.
테스트 계정, 관리자 계정 또는 알려진 부정 사용자를 리더보드에서 제외하는 데 사용합니다. 최대 10,000건. |
| generation | string | | | | ~ 256자 | 세대
현재 랭킹 세대를 나타내는 임의의 문자열입니다.
이 값을 변경하면 이전 세대의 점수는 랭킹 집계에 포함되지 않으므로 사실상 점수가 초기화됩니다.
시즌제 초기화나 정기적인 랭킹 초기화를 구현하는 데 사용합니다. 최대 256자. |
**관련 메서드:**
createCategoryModelMaster - 카테고리 모델 마스터 신규 작성
updateCategoryModelMaster - 카테고리 모델 마스터 갱신
**관련 모델:**
CategoryModel - 카테고리 모델
CategoryModelMaster - 카테고리 모델 마스터
---
### FixedTiming
집계 시각 고정 설정
글로벌 랭킹의 집계가 시작되는 고정 시각을 지정합니다.
이 설정이 없으면 랭킹 집계는 정해지지 않은 기준 시각부터 일정 간격으로 실행됩니다.
고정된 시·분을 지정함으로써 매일의 집계 시작 시각(UTC)을 예측 가능하게 할 수 있으며, 자정이나 특정 시각에 집계를 시작하도록 제어할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| hour | int | | | | 0 ~ 23 | 시
랭킹 집계가 시작되는 시각의 시(UTC)입니다.
0~23 사이의 정수로 지정합니다. |
| minute | int | | | | 0 ~ 59 | 분
지정한 시각의 분입니다.
0~59 사이의 정수로 지정합니다. |
**관련 모델:**
GlobalRankingSetting - 글로벌 랭킹 설정
---
### CalculatedAt
최종 집계일시
특정 카테고리에 대한 마지막 랭킹 집계의 타임스탬프를 기록합니다.
네임스페이스는 카테고리별로 하나씩 이 엔트리의 리스트를 유지하며, 글로벌 랭킹의 재집계가 완료될 때마다 업데이트됩니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| categoryName | string | | ✓ | | ~ 128자 | 카테고리 이름
최종 집계 시각이 추적되는 카테고리 모델의 이름입니다.
동일한 네임스페이스 내에서 정의된 CategoryModel의 name 필드와 일치합니다. |
| calculatedAt | long | | ✓ | | | 집계일시
이 카테고리의 랭킹 집계가 마지막으로 완료된 타임스탬프입니다.
UNIX 시간(밀리초)으로 표현됩니다. 랭킹 재집계가 완료되었을 때 서버가 자동으로 설정합니다. |
**관련 모델:**
Namespace - 네임스페이스
---
### CurrentRankingMaster
현재 활성화된 랭킹 모델 마스터 데이터
현재 네임스페이스 내에서 유효한 랭킹 모델의 정의를 기술한 마스터 데이터입니다.
GS2는 마스터 데이터 관리에 JSON 형식의 파일을 사용합니다.
파일을 업로드함으로써 실제로 서버에 설정을 반영할 수 있습니다.
JSON 파일을 작성하는 방법으로, 매니지먼트 콘솔 내에 마스터 데이터 에디터를 제공하고 있습니다.
또한 게임 운영에 더 적합한 도구를 직접 제작하여 적절한 형식의 JSON 파일을 출력하는 방식으로도 서비스를 이용할 수 있습니다.
**ℹ️ Note**
JSON 파일 형식에 대해서는 [GS2-Ranking 마스터 데이터 레퍼런스](api_reference/ranking/master_data/)를 참조해 주세요.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceId | string | | ※ | | ~ 1024자 | 네임스페이스 GRN
※ 서버가 자동으로 설정 |
| settings | string | | ✓ | | ~ 5242880 바이트 (5MB) | 마스터 데이터 |
**관련 메서드:**
exportMaster - 모델 마스터를 유효화 가능한 마스터 데이터 형식으로 익스포트
getCurrentRankingMaster - 현재 활성화된 랭킹 모델 마스터 데이터 취득
updateCurrentRankingMaster - 현재 활성화된 랭킹 모델의 마스터 데이터 업데이트
updateCurrentRankingMasterFromGitHub - 현재 활성화된 랭킹 모델의 마스터 데이터를 GitHub에서 업데이트
---
### CategoryModelMaster
카테고리 모델 마스터
카테고리 모델 마스터는 게임 내에서 사용되는 카테고리 모델을 편집·관리하기 위한 데이터로, 매니지먼트 콘솔의 마스터 데이터 에디터에 일시적으로 저장됩니다.
임포트·업데이트 처리를 수행함으로써 실제로 게임에서 참조되는 카테고리 모델로 반영됩니다.
카테고리별로 서로 다른 랭킹을 만들 수 있습니다.
카테고리에는 등록 가능한 점수의 최솟값·최댓값을 설정할 수 있으며, 해당 범위를 벗어난 점수는 폐기됩니다.
랭킹을 집계할 때 점수가 작은 쪽을 상위로 할지(오름차순), 큰 쪽을 상위로 할지(내림차순) 설정할 수 있습니다.
랭킹 종류로 `글로벌` 과 `스코프` 를 선택할 수 있습니다.
글로벌은 모든 플레이어가 동일한 결과를 참조하는 것이며, 스코프는 친구 랭킹이나 길드 랭킹처럼 게임 플레이어마다 결과가 다른 랭킹입니다.
글로벌 랭킹은 카테고리별로 랭킹 집계 간격을 15분~24시간으로 설정할 수 있습니다.
스코프 랭킹은 실시간으로 집계 결과가 반영됩니다.
랭킹 데이터에는 세대라는 설정이 있으며, 세대를 변경함으로써 등록된 점수를 초기화할 수 있습니다.
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| categoryModelId | 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"(내림차순)는 높은 점수를 상위로 하며, 포인트 기반이나 하이스코어 랭킹에 적합합니다.asc: 오름차순 / desc: 내림차순 / |
| scope | 문자열 열거형
enum {
"global",
"scoped"
}
| | ✓ | | | 랭킹 종류
이 카테고리의 랭킹 타입입니다.
"global" 은 모든 플레이어가 공유하는 단일 리더보드를 만들며, 설정된 간격으로 배치 집계됩니다.
"scoped" 는 구독한 플레이어(친구나 길드 멤버 등)를 기반으로 한 사용자별 리더보드를 만들며, 점수가 실시간으로 반영됩니다.global: 글로벌 / scoped: 스코프 / |
| globalRankingSetting | [GlobalRankingSetting](#globalrankingsetting) | {scope} == "global" | ✓※ | | | 글로벌 랭킹 설정
글로벌 랭킹 모드 전용 설정입니다. 집계 간격, 고정 시각, 점수의 유니크 여부, 세대 관리, 추가 기간 한정 스코프를 포함합니다.
scope 가 "global" 로 설정된 경우에만 적용됩니다.
※ scope이(가) "global" 이면 필수 |
| entryPeriodEventId | string | | | | ~ 1024자 | 점수 등록 기간 이벤트 ID
점수 등록을 받는 기간을 정의하는 GS2-Schedule 이벤트의 GRN입니다.
이 기간 외의 점수 등록 요청은 거부됩니다. 설정하지 않으면 점수는 언제든지 등록할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 접근 기간 이벤트 ID
랭킹 데이터를 열람할 수 있는 기간을 정의하는 GS2-Schedule 이벤트의 GRN입니다.
이 기간 외의 랭킹 조회 요청은 거부됩니다. 설정하지 않으면 랭킹은 언제든지 접근할 수 있습니다. |
| createdAt | long | | ※ | 현재 시각 | | 생성일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| updatedAt | long | | ※ | 현재 시각 | | 최종 갱신일시
UNIX 시간・밀리초
※ 서버가 자동으로 설정 |
| revision | long | | | 0 | 0 ~ 9223372036854775805 | 리비전 |
**관련 메서드:**
describeCategoryModelMasters - 카테고리 모델 마스터 목록 취득
createCategoryModelMaster - 카테고리 모델 마스터 신규 작성
getCategoryModelMaster - 카테고리 모델 마스터 취득
updateCategoryModelMaster - 카테고리 모델 마스터 갱신
deleteCategoryModelMaster - 카테고리 모델 마스터 삭제
---
## 메서드
### 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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeNamespaces(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeNamespacesRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeNamespacesRequest;
import io.gs2.ranking.result.DescribeNamespacesResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNamespaces(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeNamespaces(
new Gs2Ranking.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_namespaces(
ranking.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('ranking')
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('ranking')
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) | | | | | 로그 출력 설정
랭킹 관련 조작 로그를 GS2-Log에 출력하기 위한 설정입니다.
설정하면 스코어 등록, 랭킹 취득, 구독 변경 등의 작업이 분석 및 감사를 위해 기록됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 생성한 네임스페이스 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CreateNamespace(
&ranking.CreateNamespaceRequest {
Name: pointy.String("namespace-0001"),
Description: nil,
TransactionSetting: nil,
LogSetting: &ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CreateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->createNamespace(
(new CreateNamespaceRequest())
->withName("namespace-0001")
->withDescription(null)
->withTransactionSetting(null)
->withLogSetting((new \Gs2\Ranking\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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CreateNamespaceRequest;
import io.gs2.ranking.result.CreateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
CreateNamespaceResult result = client.createNamespace(
new CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(null)
.withLogSetting(new io.gs2.ranking.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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateNamespace(
new Gs2.Gs2Ranking.Request.CreateNamespaceRequest()
.WithName("namespace-0001")
.WithDescription(null)
.WithTransactionSetting(null)
.WithLogSetting(new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.createNamespace(
new Gs2Ranking.CreateNamespaceRequest()
.withName("namespace-0001")
.withDescription(null)
.withTransactionSetting(null)
.withLogSetting(new Gs2Ranking.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.create_namespace(
ranking.CreateNamespaceRequest()
.with_name('namespace-0001')
.with_description(None)
.with_transaction_setting(None)
.with_log_setting(
ranking.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('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetNamespaceStatus(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetNamespaceStatusRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetNamespaceStatusRequest;
import io.gs2.ranking.result.GetNamespaceStatusResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespaceStatus(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getNamespaceStatus(
new Gs2Ranking.GetNamespaceStatusRequest()
.withNamespaceName("namespace-0001")
);
const status = result.getStatus();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_namespace_status(
ranking.GetNamespaceStatusRequest()
.with_namespace_name('namespace-0001')
)
status = result.status
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetNamespace(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetNamespaceRequest;
import io.gs2.ranking.result.GetNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetNamespace(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getNamespace(
new Gs2Ranking.GetNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_namespace(
ranking.GetNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
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('ranking')
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) | | | | | 로그 출력 설정
랭킹 관련 조작 로그를 GS2-Log에 출력하기 위한 설정입니다.
설정하면 스코어 등록, 랭킹 취득, 구독 변경 등의 작업이 분석 및 감사를 위해 기록됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Namespace](#namespace) | 갱신한 네임스페이스 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.UpdateNamespace(
&ranking.UpdateNamespaceRequest {
NamespaceName: pointy.String("namespace-0001"),
Description: pointy.String("description1"),
TransactionSetting: nil,
LogSetting: &ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UpdateNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->updateNamespace(
(new UpdateNamespaceRequest())
->withNamespaceName("namespace-0001")
->withDescription("description1")
->withTransactionSetting(null)
->withLogSetting((new \Gs2\Ranking\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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UpdateNamespaceRequest;
import io.gs2.ranking.result.UpdateNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UpdateNamespaceResult result = client.updateNamespace(
new UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(null)
.withLogSetting(new io.gs2.ranking.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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateNamespace(
new Gs2.Gs2Ranking.Request.UpdateNamespaceRequest()
.WithNamespaceName("namespace-0001")
.WithDescription("description1")
.WithTransactionSetting(null)
.WithLogSetting(new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.updateNamespace(
new Gs2Ranking.UpdateNamespaceRequest()
.withNamespaceName("namespace-0001")
.withDescription("description1")
.withTransactionSetting(null)
.withLogSetting(new Gs2Ranking.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.update_namespace(
ranking.UpdateNamespaceRequest()
.with_namespace_name('namespace-0001')
.with_description('description1')
.with_transaction_setting(None)
.with_log_setting(
ranking.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('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DeleteNamespace(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DeleteNamespaceRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DeleteNamespaceRequest;
import io.gs2.ranking.result.DeleteNamespaceResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteNamespace(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.deleteNamespace(
new Gs2Ranking.DeleteNamespaceRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.delete_namespace(
ranking.DeleteNamespaceRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetServiceVersion(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetServiceVersionRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetServiceVersionRequest;
import io.gs2.ranking.result.GetServiceVersionResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetServiceVersion(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getServiceVersion(
new Gs2Ranking.GetServiceVersionRequest()
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_service_version(
ranking.GetServiceVersionRequest()
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DumpUserDataByUserId(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DumpUserDataByUserIdRequest;
import io.gs2.ranking.result.DumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DumpUserDataByUserId(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.dumpUserDataByUserId(
new Gs2Ranking.DumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.dump_user_data_by_user_id(
ranking.DumpUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CheckDumpUserDataByUserId(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CheckDumpUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CheckDumpUserDataByUserIdRequest;
import io.gs2.ranking.result.CheckDumpUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckDumpUserDataByUserId(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.checkDumpUserDataByUserId(
new Gs2Ranking.CheckDumpUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const url = result.getUrl();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.check_dump_user_data_by_user_id(
ranking.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('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CleanUserDataByUserId(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CleanUserDataByUserIdRequest;
import io.gs2.ranking.result.CleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CleanUserDataByUserId(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.cleanUserDataByUserId(
new Gs2Ranking.CleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.clean_user_data_by_user_id(
ranking.CleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CheckCleanUserDataByUserId(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CheckCleanUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CheckCleanUserDataByUserIdRequest;
import io.gs2.ranking.result.CheckCleanUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckCleanUserDataByUserId(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.checkCleanUserDataByUserId(
new Gs2Ranking.CheckCleanUserDataByUserIdRequest()
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.check_clean_user_data_by_user_id(
ranking.CheckCleanUserDataByUserIdRequest()
.with_user_id('user-0001')
.with_time_offset_token(None)
)
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.PrepareImportUserDataByUserId(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\PrepareImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.PrepareImportUserDataByUserIdRequest;
import io.gs2.ranking.result.PrepareImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.PrepareImportUserDataByUserId(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.prepareImportUserDataByUserId(
new Gs2Ranking.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.prepare_import_user_data_by_user_id(
ranking.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('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.ImportUserDataByUserId(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\ImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.ImportUserDataByUserIdRequest;
import io.gs2.ranking.result.ImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.ImportUserDataByUserId(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.importUserDataByUserId(
new Gs2Ranking.ImportUserDataByUserIdRequest()
.withUserId("user-0001")
.withUploadToken("upload-0001")
.withTimeOffsetToken(null)
);
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.import_user_data_by_user_id(
ranking.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('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CheckImportUserDataByUserId(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CheckImportUserDataByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CheckImportUserDataByUserIdRequest;
import io.gs2.ranking.result.CheckImportUserDataByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CheckImportUserDataByUserId(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.checkImportUserDataByUserId(
new Gs2Ranking.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.check_import_user_data_by_user_id(
ranking.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('ranking')
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('ranking')
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;
```
---
### subscribe
대상 사용자 구독
지정한 카테고리에서 지정한 대상 사용자의 랭킹을 구독합니다. 대상 사용자의 스코어가 요청한 사용자의 스코프 지정 랭킹에 포함되게 됩니다. 자기 자신을 구독할 수는 없습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | 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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.Subscribe(
&ranking.SubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\SubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->subscribe(
(new SubscribeRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.SubscribeRequest;
import io.gs2.ranking.result.SubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
SubscribeResult result = client.subscribe(
new SubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.Subscribe(
new Gs2.Gs2Ranking.Request.SubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.subscribe(
new Gs2Ranking.SubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.subscribe(
ranking.SubscribeRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-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('ranking')
api_result = client.subscribe({
namespaceName="namespace-0001",
categoryName="category-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('ranking')
api_result_handler = client.subscribe_async({
namespaceName="namespace-0001",
categoryName="category-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;
```
---
### subscribeByUserId
사용자 ID를 지정하여 대상 사용자 구독
지정한 사용자를 대신하여 지정한 카테고리에서 지정한 대상 사용자의 랭킹을 구독합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | 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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.SubscribeByUserId(
&ranking.SubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\SubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->subscribeByUserId(
(new SubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.SubscribeByUserIdRequest;
import io.gs2.ranking.result.SubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
SubscribeByUserIdResult result = client.subscribeByUserId(
new SubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.SubscribeByUserId(
new Gs2.Gs2Ranking.Request.SubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.subscribeByUserId(
new Gs2Ranking.SubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.subscribe_by_user_id(
ranking.SubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-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('ranking')
api_result = client.subscribe_by_user_id({
namespaceName="namespace-0001",
categoryName="category-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('ranking')
api_result_handler = client.subscribe_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-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;
```
---
### describeScores
스코어 목록 취득
지정한 카테고리에서 지정한 스코어 등록자가 등록한 스코어 목록을 페이지네이션으로 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름 |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| scorerUserId | string | | ✓| | ~ 128자 | 사용자ID |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Score>](#score) | 스코어 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeScores(
&ranking.DescribeScoresRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
ScorerUserId: pointy.String("user-0002"),
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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeScoresRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeScores(
(new DescribeScoresRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withScorerUserId("user-0002")
->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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeScoresRequest;
import io.gs2.ranking.result.DescribeScoresResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeScoresResult result = client.describeScores(
new DescribeScoresRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0002")
.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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeScores(
new Gs2.Gs2Ranking.Request.DescribeScoresRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithScorerUserId("user-0002")
.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeScores(
new Gs2Ranking.DescribeScoresRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0002")
.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_scores(
ranking.DescribeScoresRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_scorer_user_id('user-0002')
.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('ranking')
api_result = client.describe_scores({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0002",
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('ranking')
api_result_handler = client.describe_scores_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0002",
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;
```
---
### describeScoresByUserId
사용자 ID를 지정하여 스코어 목록 취득
지정한 사용자에 대해, 지정한 카테고리에서 지정한 스코어 등록자가 등록한 스코어 목록을 페이지네이션으로 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름 |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| scorerUserId | string | | ✓| | ~ 128자 | 사용자ID |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Score>](#score) | 스코어 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeScoresByUserId(
&ranking.DescribeScoresByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
ScorerUserId: pointy.String("user-0002"),
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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeScoresByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeScoresByUserId(
(new DescribeScoresByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withScorerUserId("user-0002")
->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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeScoresByUserIdRequest;
import io.gs2.ranking.result.DescribeScoresByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeScoresByUserIdResult result = client.describeScoresByUserId(
new DescribeScoresByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0002")
.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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeScoresByUserId(
new Gs2.Gs2Ranking.Request.DescribeScoresByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithScorerUserId("user-0002")
.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeScoresByUserId(
new Gs2Ranking.DescribeScoresByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0002")
.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_scores_by_user_id(
ranking.DescribeScoresByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_scorer_user_id('user-0002')
.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('ranking')
api_result = client.describe_scores_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0002",
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('ranking')
api_result_handler = client.describe_scores_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0002",
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;
```
---
### getScore
스코어 취득
카테고리, 스코어 등록자의 사용자 ID, 고유 ID를 지정하여 특정 스코어 레코드를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리명 |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| scorerUserId | string | | ✓| | ~ 128자 | 사용자ID |
| uniqueId | string | | | "0" | ~ 36자 | 스코어의 고유 ID |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Score](#score) | 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetScore(
&ranking.GetScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
ScorerUserId: pointy.String("user-0002"),
UniqueId: pointy.String("unique-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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getScore(
(new GetScoreRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withScorerUserId("user-0002")
->withUniqueId("unique-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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetScoreRequest;
import io.gs2.ranking.result.GetScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetScoreResult result = client.getScore(
new GetScoreRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0002")
.withUniqueId("unique-0001")
);
Score 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetScore(
new Gs2.Gs2Ranking.Request.GetScoreRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithScorerUserId("user-0002")
.WithUniqueId("unique-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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getScore(
new Gs2Ranking.GetScoreRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0002")
.withUniqueId("unique-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_score(
ranking.GetScoreRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_scorer_user_id('user-0002')
.with_unique_id('unique-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_score({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0002",
uniqueId="unique-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('ranking')
api_result_handler = client.get_score_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0002",
uniqueId="unique-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;
```
---
### getScoreByUserId
사용자 ID를 지정하여 스코어 취득
지정한 사용자에 대해, 카테고리, 스코어 등록자의 사용자 ID, 고유 ID를 지정하여 특정 스코어 레코드를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리명 |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| scorerUserId | string | | ✓| | ~ 128자 | 사용자ID |
| uniqueId | string | | | "0" | ~ 36자 | 스코어의 고유 ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Score](#score) | 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetScoreByUserId(
&ranking.GetScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
ScorerUserId: pointy.String("user-0002"),
UniqueId: pointy.String("unique-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getScoreByUserId(
(new GetScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withScorerUserId("user-0002")
->withUniqueId("unique-0001")
->withTimeOffsetToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetScoreByUserIdRequest;
import io.gs2.ranking.result.GetScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetScoreByUserIdResult result = client.getScoreByUserId(
new GetScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0002")
.withUniqueId("unique-0001")
.withTimeOffsetToken(null)
);
Score 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetScoreByUserId(
new Gs2.Gs2Ranking.Request.GetScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithScorerUserId("user-0002")
.WithUniqueId("unique-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getScoreByUserId(
new Gs2Ranking.GetScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0002")
.withUniqueId("unique-0001")
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_score_by_user_id(
ranking.GetScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_scorer_user_id('user-0002')
.with_unique_id('unique-0001')
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_score_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0002",
uniqueId="unique-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.get_score_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0002",
uniqueId="unique-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### describeRankings
랭킹 취득
지정한 카테고리의 랭킹을 페이지네이션으로 취득합니다. 글로벌 랭킹과 스코프 지정 랭킹 양쪽 모두를 지원합니다. 시작 인덱스를 지정하여 특정 순위부터 취득을 시작할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | | | ~ 128자 | 액세스 토큰 |
| additionalScopeName | string | | | | ~ 128자 | 스코프 이름
카테고리 내에서 이 집계 스코프를 고유하게 식별하는 이름입니다.
여러 개의 기간 한정 랭킹 보드를 구분하기 위해 사용됩니다(예: "daily", "weekly"). 최대 128자. |
| startIndex | long | | | | 0 ~ 9223372036854775805 | 랭킹 취득을 시작할 인덱스 |
| pageToken | string | | | | ~ 4096자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Ranking>](#ranking) | 랭킹 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeRankings(
&ranking.DescribeRankingsRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
AdditionalScopeName: nil,
StartIndex: 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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeRankingsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeRankings(
(new DescribeRankingsRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withAdditionalScopeName(null)
->withStartIndex(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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeRankingsRequest;
import io.gs2.ranking.result.DescribeRankingsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeRankingsResult result = client.describeRankings(
new DescribeRankingsRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withAdditionalScopeName(null)
.withStartIndex(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeRankings(
new Gs2.Gs2Ranking.Request.DescribeRankingsRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithAdditionalScopeName(null)
.WithStartIndex(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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeRankings(
new Gs2Ranking.DescribeRankingsRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withAdditionalScopeName(null)
.withStartIndex(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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_rankings(
ranking.DescribeRankingsRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_additional_scope_name(None)
.with_start_index(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('ranking')
api_result = client.describe_rankings({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
additionalScopeName=nil,
startIndex=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('ranking')
api_result_handler = client.describe_rankings_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
additionalScopeName=nil,
startIndex=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;
```
---
### describeRankingssByUserId
사용자 ID를 지정하여 랭킹 취득
지정한 카테고리와 사용자의 랭킹을 페이지네이션으로 취득합니다. 글로벌 랭킹과 스코프 지정 랭킹 양쪽 모두를 지원합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | | | ~ 128자 | 사용자ID |
| additionalScopeName | string | | | | ~ 128자 | 스코프 이름
카테고리 내에서 이 집계 스코프를 고유하게 식별하는 이름입니다.
여러 개의 기간 한정 랭킹 보드를 구분하기 위해 사용됩니다(예: "daily", "weekly"). 최대 128자. |
| startIndex | long | | | | 0 ~ 9223372036854775805 | 랭킹 취득을 시작할 인덱스 |
| pageToken | string | | | | ~ 4096자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Ranking>](#ranking) | 랭킹 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeRankingssByUserId(
&ranking.DescribeRankingssByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
AdditionalScopeName: nil,
StartIndex: pointy.Int64(0),
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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeRankingssByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeRankingssByUserId(
(new DescribeRankingssByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withAdditionalScopeName(null)
->withStartIndex(0)
->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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeRankingssByUserIdRequest;
import io.gs2.ranking.result.DescribeRankingssByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeRankingssByUserIdResult result = client.describeRankingssByUserId(
new DescribeRankingssByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withAdditionalScopeName(null)
.withStartIndex(0L)
.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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeRankingssByUserId(
new Gs2.Gs2Ranking.Request.DescribeRankingssByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithAdditionalScopeName(null)
.WithStartIndex(0L)
.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeRankingssByUserId(
new Gs2Ranking.DescribeRankingssByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withAdditionalScopeName(null)
.withStartIndex(0)
.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_rankingss_by_user_id(
ranking.DescribeRankingssByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_additional_scope_name(None)
.with_start_index(0)
.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('ranking')
api_result = client.describe_rankingss_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
additionalScopeName=nil,
startIndex=0,
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('ranking')
api_result_handler = client.describe_rankingss_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
additionalScopeName=nil,
startIndex=0,
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;
```
---
### describeNearRankings
지정한 스코어 부근의 랭킹 취득
이 API는 글로벌 랭킹일 때만 사용할 수 있습니다
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| additionalScopeName | string | | | | ~ 128자 | 스코프 이름
카테고리 내에서 이 집계 스코프를 고유하게 식별하는 이름입니다.
여러 개의 기간 한정 랭킹 보드를 구분하기 위해 사용됩니다(예: "daily", "weekly"). 최대 128자. |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
이 랭킹 엔트리의 스코어 값입니다.
합산 모드의 경우, 등록된 모든 스코어의 누적 합계입니다. 랭킹 정렬 순서에 사용되는 값은 카테고리의 orderDirection 설정에 따라 달라집니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<Ranking>](#ranking) | 랭킹 목록 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeNearRankings(
&ranking.DescribeNearRankingsRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AdditionalScopeName: nil,
Score: pointy.Int64(1000),
}
)
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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeNearRankingsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeNearRankings(
(new DescribeNearRankingsRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAdditionalScopeName(null)
->withScore(1000)
);
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeNearRankingsRequest;
import io.gs2.ranking.result.DescribeNearRankingsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeNearRankingsResult result = client.describeNearRankings(
new DescribeNearRankingsRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAdditionalScopeName(null)
.withScore(1000L)
);
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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeNearRankings(
new Gs2.Gs2Ranking.Request.DescribeNearRankingsRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAdditionalScopeName(null)
.WithScore(1000L),
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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeNearRankings(
new Gs2Ranking.DescribeNearRankingsRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAdditionalScopeName(null)
.withScore(1000)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_near_rankings(
ranking.DescribeNearRankingsRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_additional_scope_name(None)
.with_score(1000)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_near_rankings({
namespaceName="namespace-0001",
categoryName="category-0001",
additionalScopeName=nil,
score=1000,
})
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('ranking')
api_result_handler = client.describe_near_rankings_async({
namespaceName="namespace-0001",
categoryName="category-0001",
additionalScopeName=nil,
score=1000,
})
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;
```
---
### getRanking
랭킹 취득
특정 스코어 등록자의 스코어에 대한 랭킹 정보(순위 포함)를 취득합니다. 지정한 스코어 부근의 랭킹도 함께 반환합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| scorerUserId | string | | ✓| | ~ 128자 | 스코어를 획득한 사용자의 사용자 ID |
| uniqueId | string | | | "0" | ~ 36자 | 스코어의 고유 ID |
| additionalScopeName | string | | | | ~ 128자 | 스코프 이름
카테고리 내에서 이 집계 스코프를 고유하게 식별하는 이름입니다.
여러 개의 기간 한정 랭킹 보드를 구분하기 위해 사용됩니다(예: "daily", "weekly"). 최대 128자. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Ranking](#ranking) | 랭킹 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetRanking(
&ranking.GetRankingRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
ScorerUserId: pointy.String("user-0001"),
UniqueId: pointy.String("unique-id"),
AdditionalScopeName: 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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetRankingRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getRanking(
(new GetRankingRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withScorerUserId("user-0001")
->withUniqueId("unique-id")
->withAdditionalScopeName(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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetRankingRequest;
import io.gs2.ranking.result.GetRankingResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetRankingResult result = client.getRanking(
new GetRankingRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0001")
.withUniqueId("unique-id")
.withAdditionalScopeName(null)
);
Ranking 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetRanking(
new Gs2.Gs2Ranking.Request.GetRankingRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithScorerUserId("user-0001")
.WithUniqueId("unique-id")
.WithAdditionalScopeName(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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getRanking(
new Gs2Ranking.GetRankingRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScorerUserId("user-0001")
.withUniqueId("unique-id")
.withAdditionalScopeName(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_ranking(
ranking.GetRankingRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_scorer_user_id('user-0001')
.with_unique_id('unique-id')
.with_additional_scope_name(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_ranking({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0001",
uniqueId="unique-id",
additionalScopeName=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('ranking')
api_result_handler = client.get_ranking_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
scorerUserId="user-0001",
uniqueId="unique-id",
additionalScopeName=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;
```
---
### getRankingByUserId
사용자 ID를 지정하여 랭킹 취득
지정한 사용자에서의 특정 스코어 등록자의 스코어에 대한 랭킹 정보(순위 포함)를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 랭킹을 취득할 사용자 ID(GS2-Schedule의 기간 판정에 사용됩니다.) |
| scorerUserId | string | | ✓| | ~ 128자 | 스코어를 획득한 사용자의 사용자 ID |
| uniqueId | string | | | "0" | ~ 36자 | 스코어의 고유 ID |
| additionalScopeName | string | | | | ~ 128자 | 스코프 이름
카테고리 내에서 이 집계 스코프를 고유하게 식별하는 이름입니다.
여러 개의 기간 한정 랭킹 보드를 구분하기 위해 사용됩니다(예: "daily", "weekly"). 최대 128자. |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Ranking](#ranking) | 랭킹 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetRankingByUserId(
&ranking.GetRankingByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
ScorerUserId: pointy.String("user-0001"),
UniqueId: pointy.String("unique-id"),
AdditionalScopeName: 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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetRankingByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getRankingByUserId(
(new GetRankingByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withScorerUserId("user-0001")
->withUniqueId("unique-id")
->withAdditionalScopeName(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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetRankingByUserIdRequest;
import io.gs2.ranking.result.GetRankingByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetRankingByUserIdResult result = client.getRankingByUserId(
new GetRankingByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0001")
.withUniqueId("unique-id")
.withAdditionalScopeName(null)
.withTimeOffsetToken(null)
);
Ranking 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetRankingByUserId(
new Gs2.Gs2Ranking.Request.GetRankingByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithScorerUserId("user-0001")
.WithUniqueId("unique-id")
.WithAdditionalScopeName(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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getRankingByUserId(
new Gs2Ranking.GetRankingByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScorerUserId("user-0001")
.withUniqueId("unique-id")
.withAdditionalScopeName(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_ranking_by_user_id(
ranking.GetRankingByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_scorer_user_id('user-0001')
.with_unique_id('unique-id')
.with_additional_scope_name(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_ranking_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0001",
uniqueId="unique-id",
additionalScopeName=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('ranking')
api_result_handler = client.get_ranking_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
scorerUserId="user-0001",
uniqueId="unique-id",
additionalScopeName=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;
```
---
### putScore
스코어 등록
지정한 랭킹 카테고리에 요청한 사용자의 스코어를 등록합니다. 카테고리 타입에 따라 글로벌 랭킹 또는 스코프 지정 랭킹 처리로 분류됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
이 랭킹 엔트리의 스코어 값입니다.
합산 모드의 경우, 등록된 모든 스코어의 누적 합계입니다. 랭킹 정렬 순서에 사용되는 값은 카테고리의 orderDirection 설정에 따라 달라집니다. |
| metadata | string | | | | ~ 512자 | 메타데이터
이 랭킹 엔트리에 연결된 임의의 메타데이터입니다.
스코어 등록 시 설정되며, 랭킹 결과와 함께 반환됩니다. 최대 512자. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Score](#score) | 등록한 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.PutScore(
&ranking.PutScoreRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
Score: pointy.Int64(1000),
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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\PutScoreRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->putScore(
(new PutScoreRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
->withScore(1000)
->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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.PutScoreRequest;
import io.gs2.ranking.result.PutScoreResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
PutScoreResult result = client.putScore(
new PutScoreRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScore(1000L)
.withMetadata(null)
);
Score 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.PutScore(
new Gs2.Gs2Ranking.Request.PutScoreRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001")
.WithScore(1000L)
.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.putScore(
new Gs2Ranking.PutScoreRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
.withScore(1000)
.withMetadata(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.put_score(
ranking.PutScoreRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
.with_score(1000)
.with_metadata(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.put_score({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
score=1000,
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('ranking')
api_result_handler = client.put_score_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
score=1000,
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;
```
---
### putScoreByUserId
사용자 ID를 지정하여 스코어 등록
지정한 랭킹 카테고리에 지정한 사용자의 스코어를 등록합니다. 카테고리 타입에 따라 글로벌 랭킹 또는 스코프 지정 랭킹 처리로 분류됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| score | long | | ✓| | 0 ~ 9223372036854775805 | 스코어
이 랭킹 엔트리의 스코어 값입니다.
합산 모드의 경우, 등록된 모든 스코어의 누적 합계입니다. 랭킹 정렬 순서에 사용되는 값은 카테고리의 orderDirection 설정에 따라 달라집니다. |
| metadata | string | | | | ~ 512자 | 메타데이터
이 랭킹 엔트리에 연결된 임의의 메타데이터입니다.
스코어 등록 시 설정되며, 랭킹 결과와 함께 반환됩니다. 최대 512자. |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [Score](#score) | 등록한 스코어 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.PutScoreByUserId(
&ranking.PutScoreByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
Score: pointy.Int64(1000),
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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\PutScoreByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->putScoreByUserId(
(new PutScoreByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withScore(1000)
->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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.PutScoreByUserIdRequest;
import io.gs2.ranking.result.PutScoreByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
PutScoreByUserIdResult result = client.putScoreByUserId(
new PutScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScore(1000L)
.withMetadata(null)
.withTimeOffsetToken(null)
);
Score 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.PutScoreByUserId(
new Gs2.Gs2Ranking.Request.PutScoreByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithScore(1000L)
.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.putScoreByUserId(
new Gs2Ranking.PutScoreByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withScore(1000)
.withMetadata(null)
.withTimeOffsetToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.put_score_by_user_id(
ranking.PutScoreByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_score(1000)
.with_metadata(None)
.with_time_offset_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.put_score_by_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
score=1000,
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('ranking')
api_result_handler = client.put_score_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
score=1000,
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;
```
---
### calcRanking
랭킹 계산 처리의 강제 실행
예약된 계산 시점과 관계없이 지정한 카테고리의 랭킹 재계산을 즉시 실행합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름 |
| additionalScopeName | string | | | | ~ 128자 | 추가 스코프 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| processing | bool | 비동기 처리로 집계 처리가 진행 중인지 여부 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CalcRanking(
&ranking.CalcRankingRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AdditionalScopeName: nil,
}
)
if err != nil {
panic("error occurred")
}
processing := result.Processing
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CalcRankingRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->calcRanking(
(new CalcRankingRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAdditionalScopeName(null)
);
$processing = $result->getProcessing();
} 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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CalcRankingRequest;
import io.gs2.ranking.result.CalcRankingResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
CalcRankingResult result = client.calcRanking(
new CalcRankingRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAdditionalScopeName(null)
);
boolean processing = result.getProcessing();
} 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CalcRanking(
new Gs2.Gs2Ranking.Request.CalcRankingRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAdditionalScopeName(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var processing = result.Processing;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.calcRanking(
new Gs2Ranking.CalcRankingRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAdditionalScopeName(null)
);
const processing = result.getProcessing();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.calc_ranking(
ranking.CalcRankingRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_additional_scope_name(None)
)
processing = result.processing
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.calc_ranking({
namespaceName="namespace-0001",
categoryName="category-0001",
additionalScopeName=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
processing = result.processing;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.calc_ranking_async({
namespaceName="namespace-0001",
categoryName="category-0001",
additionalScopeName=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
processing = result.processing;
```
---
### getSubscribe
구독 대상 사용자 정보 취득
지정한 랭킹 카테고리에서 특정 대상 사용자의 구독 정보를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | 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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetSubscribe(
&ranking.GetSubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetSubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getSubscribe(
(new GetSubscribeRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetSubscribeRequest;
import io.gs2.ranking.result.GetSubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetSubscribeResult result = client.getSubscribe(
new GetSubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribe(
new Gs2.Gs2Ranking.Request.GetSubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getSubscribe(
new Gs2Ranking.GetSubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_subscribe(
ranking.GetSubscribeRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-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('ranking')
api_result = client.get_subscribe({
namespaceName="namespace-0001",
categoryName="category-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('ranking')
api_result_handler = client.get_subscribe_async({
namespaceName="namespace-0001",
categoryName="category-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를 지정하여 구독 정보 취득
지정한 사용자에 대해, 지정한 랭킹 카테고리의 특정 대상 사용자에 대한 구독 정보를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | 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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetSubscribeByUserId(
&ranking.GetSubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetSubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getSubscribeByUserId(
(new GetSubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetSubscribeByUserIdRequest;
import io.gs2.ranking.result.GetSubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetSubscribeByUserIdResult result = client.getSubscribeByUserId(
new GetSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetSubscribeByUserId(
new Gs2.Gs2Ranking.Request.GetSubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getSubscribeByUserId(
new Gs2Ranking.GetSubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_subscribe_by_user_id(
ranking.GetSubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-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('ranking')
api_result = client.get_subscribe_by_user_id({
namespaceName="namespace-0001",
categoryName="category-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('ranking')
api_result_handler = client.get_subscribe_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-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;
```
---
### unsubscribe
대상 사용자의 구독 해제
지정한 카테고리에서 지정한 대상 사용자의 랭킹 구독을 해제합니다. 대상 사용자의 스코어는 요청한 사용자의 스코프 랭킹에 더 이상 표시되지 않습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | 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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.Unsubscribe(
&ranking.UnsubscribeRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UnsubscribeRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->unsubscribe(
(new UnsubscribeRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UnsubscribeRequest;
import io.gs2.ranking.result.UnsubscribeResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UnsubscribeResult result = client.unsubscribe(
new UnsubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.Unsubscribe(
new Gs2.Gs2Ranking.Request.UnsubscribeRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.unsubscribe(
new Gs2Ranking.UnsubscribeRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.unsubscribe(
ranking.UnsubscribeRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-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('ranking')
api_result = client.unsubscribe({
namespaceName="namespace-0001",
categoryName="category-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('ranking')
api_result_handler = client.unsubscribe_async({
namespaceName="namespace-0001",
categoryName="category-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;
```
---
### unsubscribeByUserId
사용자 ID를 지정하여 대상 사용자의 구독 해제
지정한 사용자를 대신하여, 지정한 카테고리에서 지정한 대상 사용자의 랭킹 구독을 해제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | 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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.UnsubscribeByUserId(
&ranking.UnsubscribeByUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UnsubscribeByUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->unsubscribeByUserId(
(new UnsubscribeByUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UnsubscribeByUserIdRequest;
import io.gs2.ranking.result.UnsubscribeByUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UnsubscribeByUserIdResult result = client.unsubscribeByUserId(
new UnsubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.UnsubscribeByUserId(
new Gs2.Gs2Ranking.Request.UnsubscribeByUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.unsubscribeByUserId(
new Gs2Ranking.UnsubscribeByUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.unsubscribe_by_user_id(
ranking.UnsubscribeByUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-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('ranking')
api_result = client.unsubscribe_by_user_id({
namespaceName="namespace-0001",
categoryName="category-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('ranking')
api_result_handler = client.unsubscribe_by_user_id_async({
namespaceName="namespace-0001",
categoryName="category-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;
```
---
### describeSubscribesByCategoryName
구독 중인 사용자의 사용자 ID 목록 취득
지정한 랭킹 카테고리에서 요청한 사용자가 구독하고 있는 사용자의 목록을 취득합니다. 구독 사용자의 스코어는 스코프 지정 랭킹에 포함됩니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름 |
| accessToken | string | | ✓| | ~ 128자 | 액세스 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SubscribeUser>](#subscribeuser) | 구독 대상 사용자 정보 목록 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeSubscribesByCategoryName(
&ranking.DescribeSubscribesByCategoryNameRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
AccessToken: pointy.String("accessToken-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeSubscribesByCategoryNameRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeSubscribesByCategoryName(
(new DescribeSubscribesByCategoryNameRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withAccessToken("accessToken-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeSubscribesByCategoryNameRequest;
import io.gs2.ranking.result.DescribeSubscribesByCategoryNameResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeSubscribesByCategoryNameResult result = client.describeSubscribesByCategoryName(
new DescribeSubscribesByCategoryNameRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribesByCategoryName(
new Gs2.Gs2Ranking.Request.DescribeSubscribesByCategoryNameRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithAccessToken("accessToken-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeSubscribesByCategoryName(
new Gs2Ranking.DescribeSubscribesByCategoryNameRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withAccessToken("accessToken-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_subscribes_by_category_name(
ranking.DescribeSubscribesByCategoryNameRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_access_token('accessToken-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_subscribes_by_category_name({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_subscribes_by_category_name_async({
namespaceName="namespace-0001",
categoryName="category-0001",
accessToken="accessToken-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describeSubscribesByCategoryNameAndUserId
사용자 ID를 지정하여 해당 사용자가 구독하고 있는 사용자 목록 취득
지정한 랭킹 카테고리에서 지정한 사용자가 구독하고 있는 사용자의 목록을 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름 |
| userId | string | | ✓| | ~ 128자 | 사용자ID |
| timeOffsetToken | string | | | | ~ 1024자 | 타임 오프셋 토큰 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<SubscribeUser>](#subscribeuser) | 구독 대상 사용자 정보 목록 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeSubscribesByCategoryNameAndUserId(
&ranking.DescribeSubscribesByCategoryNameAndUserIdRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
UserId: pointy.String("user-0001"),
TimeOffsetToken: nil,
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeSubscribesByCategoryNameAndUserIdRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeSubscribesByCategoryNameAndUserId(
(new DescribeSubscribesByCategoryNameAndUserIdRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withUserId("user-0001")
->withTimeOffsetToken(null)
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeSubscribesByCategoryNameAndUserIdRequest;
import io.gs2.ranking.result.DescribeSubscribesByCategoryNameAndUserIdResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeSubscribesByCategoryNameAndUserIdResult result = client.describeSubscribesByCategoryNameAndUserId(
new DescribeSubscribesByCategoryNameAndUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeSubscribesByCategoryNameAndUserId(
new Gs2.Gs2Ranking.Request.DescribeSubscribesByCategoryNameAndUserIdRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithUserId("user-0001")
.WithTimeOffsetToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeSubscribesByCategoryNameAndUserId(
new Gs2Ranking.DescribeSubscribesByCategoryNameAndUserIdRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withUserId("user-0001")
.withTimeOffsetToken(null)
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_subscribes_by_category_name_and_user_id(
ranking.DescribeSubscribesByCategoryNameAndUserIdRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_user_id('user-0001')
.with_time_offset_token(None)
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_subscribes_by_category_name_and_user_id({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
timeOffsetToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_subscribes_by_category_name_and_user_id_async({
namespaceName="namespace-0001",
categoryName="category-0001",
userId="user-0001",
timeOffsetToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### describeCategoryModels
카테고리 모델 목록 취득
현재 활성화된 카테고리 모델의 목록을 취득합니다. 카테고리 모델은 스코어링 규칙, 계산 설정, 스코프 설정을 포함한 랭킹 카테고리를 정의합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<CategoryModel>](#categorymodel) | 카테고리 모델 목록 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeCategoryModels(
&ranking.DescribeCategoryModelsRequest {
NamespaceName: pointy.String("namespace-0001"),
}
)
if err != nil {
panic("error occurred")
}
items := result.Items
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeCategoryModelsRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeCategoryModels(
(new DescribeCategoryModelsRequest())
->withNamespaceName("namespace-0001")
);
$items = $result->getItems();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeCategoryModelsRequest;
import io.gs2.ranking.result.DescribeCategoryModelsResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeCategoryModelsResult result = client.describeCategoryModels(
new DescribeCategoryModelsRequest()
.withNamespaceName("namespace-0001")
);
List items = result.getItems();
} catch (Gs2Exception e) {
System.exit(1);
}
```
**C#**
```csharp
using Gs2.Core;
using Gs2.Core.Model;
using Gs2.Core.Net;
using Gs2.Core.Exception;
var session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region.ApNortheast1
);
yield return session.OpenAsync(r => { });
var client = new Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCategoryModels(
new Gs2.Gs2Ranking.Request.DescribeCategoryModelsRequest()
.WithNamespaceName("namespace-0001"),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var items = result.Items;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeCategoryModels(
new Gs2Ranking.DescribeCategoryModelsRequest()
.withNamespaceName("namespace-0001")
);
const items = result.getItems();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_category_models(
ranking.DescribeCategoryModelsRequest()
.with_namespace_name('namespace-0001')
)
items = result.items
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.describe_category_models({
namespaceName="namespace-0001",
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.describe_category_models_async({
namespaceName="namespace-0001",
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
items = result.items;
```
---
### getCategoryModel
카테고리 모델 취득
스코어 범위, 정렬 순서, 스코프 타입, 글로벌 랭킹 설정, 엔트리/액세스 기간 이벤트 설정을 포함한 지정된 카테고리 모델을 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CategoryModel](#categorymodel) | 카테고리 모델 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetCategoryModel(
&ranking.GetCategoryModelRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetCategoryModelRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getCategoryModel(
(new GetCategoryModelRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetCategoryModelRequest;
import io.gs2.ranking.result.GetCategoryModelResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetCategoryModelResult result = client.getCategoryModel(
new GetCategoryModelRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
CategoryModel 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCategoryModel(
new Gs2.Gs2Ranking.Request.GetCategoryModelRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getCategoryModel(
new Gs2Ranking.GetCategoryModelRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_category_model(
ranking.GetCategoryModelRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_category_model({
namespaceName="namespace-0001",
categoryName="category-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('ranking')
api_result_handler = client.get_category_model_async({
namespaceName="namespace-0001",
categoryName="category-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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.ExportMaster(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\ExportMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.ExportMasterRequest;
import io.gs2.ranking.result.ExportMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.ExportMaster(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.exportMaster(
new Gs2Ranking.ExportMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.export_master(
ranking.ExportMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetCurrentRankingMaster(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetCurrentRankingMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetCurrentRankingMasterRequest;
import io.gs2.ranking.result.GetCurrentRankingMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCurrentRankingMaster(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getCurrentRankingMaster(
new Gs2Ranking.GetCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_current_ranking_master(
ranking.GetCurrentRankingMasterRequest()
.with_namespace_name('namespace-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.PreUpdateCurrentRankingMaster(
&ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\PreUpdateCurrentRankingMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.PreUpdateCurrentRankingMasterRequest;
import io.gs2.ranking.result.PreUpdateCurrentRankingMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.PreUpdateCurrentRankingMaster(
new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.preUpdateCurrentRankingMaster(
new Gs2Ranking.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.pre_update_current_ranking_master(
ranking.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('ranking')
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('ranking')
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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.UpdateCurrentRankingMaster(
&ranking.UpdateCurrentRankingMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Mode: pointy.String("direct"),
Settings: pointy.String("{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}"),
UploadToken: nil,
}
)
if err != nil {
panic("error occurred")
}
item := result.Item
```
**PHP**
```php
use Gs2\Core\Model\BasicGs2Credential;
use Gs2\Core\Model\Region;
use Gs2\Core\Net\Gs2RestSession;
use Gs2\Core\Exception\Gs2Exception;
use Gs2\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UpdateCurrentRankingMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->updateCurrentRankingMaster(
(new UpdateCurrentRankingMasterRequest())
->withNamespaceName("namespace-0001")
->withMode("direct")
->withSettings("{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}")
->withUploadToken(null)
);
$item = $result->getItem();
} catch (Gs2Exception $e) {
exit("error occurred")
}
```
**Java**
```java
import io.gs2.core.model.Region;
import io.gs2.core.model.BasicGs2Credential;
import io.gs2.core.rest.Gs2RestSession;
import io.gs2.core.exception.Gs2Exception;
import io.gs2.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UpdateCurrentRankingMasterRequest;
import io.gs2.ranking.result.UpdateCurrentRankingMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UpdateCurrentRankingMasterResult result = client.updateCurrentRankingMaster(
new UpdateCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}")
.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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentRankingMaster(
new Gs2.Gs2Ranking.Request.UpdateCurrentRankingMasterRequest()
.WithNamespaceName("namespace-0001")
.WithMode("direct")
.WithSettings("{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}")
.WithUploadToken(null),
r => asyncResult = r
);
if (asyncResult.Error != null) {
throw asyncResult.Error;
}
var result = asyncResult.Result;
var item = result.Item;
```
**TypeScript**
```typescript
import Gs2Core from '@/gs2/core';
import * as Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.updateCurrentRankingMaster(
new Gs2Ranking.UpdateCurrentRankingMasterRequest()
.withNamespaceName("namespace-0001")
.withMode("direct")
.withSettings("{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}")
.withUploadToken(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.update_current_ranking_master(
ranking.UpdateCurrentRankingMasterRequest()
.with_namespace_name('namespace-0001')
.with_mode('direct')
.with_settings('{\n "version": "2019-09-17",\n "categoryModels": [\n {\n "name": "category-0001",\n "orderDirection": "asc",\n "scope": "global",\n "uniqueByUserId": false,\n "sum": false,\n "calculateFixedTimingHour": -1,\n "calculateFixedTimingMinute": 0,\n "calculateIntervalMinutes": 15,\n "additionalScopes": [\n {\n "name": "daily",\n "targetDays": 1\n },\n {\n "name": "weekly",\n "targetDays": 7\n }\n ],\n "ignoreUserIds": []\n },\n {\n "name": "category-0002",\n "metadata": "CATEGORY_0002",\n "minimumValue": 1000,\n "maximumValue": 100000,\n "orderDirection": "asc",\n "scope": "scoped",\n "uniqueByUserId": true,\n "sum": false,\n "calculateFixedTimingHour": -1,\n "calculateFixedTimingMinute": 0,\n "calculateIntervalMinutes": 60,\n "additionalScopes": [],\n "ignoreUserIds": []\n }\n ]\n}')
.with_upload_token(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.update_current_ranking_master({
namespaceName="namespace-0001",
mode="direct",
settings="{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}",
uploadToken=nil,
})
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
**GS2-Script(Async)**
```lua
client = gs2('ranking')
api_result_handler = client.update_current_ranking_master_async({
namespaceName="namespace-0001",
mode="direct",
settings="{\n \"version\": \"2019-09-17\",\n \"categoryModels\": [\n {\n \"name\": \"category-0001\",\n \"orderDirection\": \"asc\",\n \"scope\": \"global\",\n \"uniqueByUserId\": false,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 15,\n \"additionalScopes\": [\n {\n \"name\": \"daily\",\n \"targetDays\": 1\n },\n {\n \"name\": \"weekly\",\n \"targetDays\": 7\n }\n ],\n \"ignoreUserIds\": []\n },\n {\n \"name\": \"category-0002\",\n \"metadata\": \"CATEGORY_0002\",\n \"minimumValue\": 1000,\n \"maximumValue\": 100000,\n \"orderDirection\": \"asc\",\n \"scope\": \"scoped\",\n \"uniqueByUserId\": true,\n \"sum\": false,\n \"calculateFixedTimingHour\": -1,\n \"calculateFixedTimingMinute\": 0,\n \"calculateIntervalMinutes\": 60,\n \"additionalScopes\": [],\n \"ignoreUserIds\": []\n }\n ]\n}",
uploadToken=nil,
})
api_result = api_result_handler() -- Call the handler to get the result
if(api_result.isError) then
-- When error occurs
fail(api_result['statusCode'], api_result['errorMessage'])
end
result = api_result.result
item = result.item;
```
---
### 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/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.UpdateCurrentRankingMasterFromGitHub(
&ranking.UpdateCurrentRankingMasterFromGitHubRequest {
NamespaceName: pointy.String("namespace-0001"),
CheckoutSetting: &ranking.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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UpdateCurrentRankingMasterFromGitHubRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UpdateCurrentRankingMasterFromGitHubRequest;
import io.gs2.ranking.result.UpdateCurrentRankingMasterFromGitHubResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCurrentRankingMasterFromGitHub(
new Gs2.Gs2Ranking.Request.UpdateCurrentRankingMasterFromGitHubRequest()
.WithNamespaceName("namespace-0001")
.WithCheckoutSetting(new Gs2.Gs2Ranking.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.updateCurrentRankingMasterFromGitHub(
new Gs2Ranking.UpdateCurrentRankingMasterFromGitHubRequest()
.withNamespaceName("namespace-0001")
.withCheckoutSetting(new Gs2Ranking.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.update_current_ranking_master_from_git_hub(
ranking.UpdateCurrentRankingMasterFromGitHubRequest()
.with_namespace_name('namespace-0001')
.with_checkout_setting(ranking.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('ranking')
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('ranking')
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;
```
---
### describeCategoryModelMasters
카테고리 모델 마스터 목록 취득
카테고리 모델 마스터의 페이지네이션 목록을 취득합니다. 이름의 접두사로 필터링할 수 있습니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| namePrefix | string | | | | ~ 64자 | 카테고리 모델명 필터 접두사 |
| pageToken | string | | | | ~ 1024자 | 데이터 취득을 시작할 위치를 지정하는 토큰 |
| limit | int | | | 30 | 1 ~ 1000 | 취득할 데이터 건수 |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| items | [List<CategoryModelMaster>](#categorymodelmaster) | 카테고리 모델 마스터 목록 |
| nextPageToken | string | 목록의 나머지를 취득하기 위한 페이지 토큰 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DescribeCategoryModelMasters(
&ranking.DescribeCategoryModelMastersRequest {
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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DescribeCategoryModelMastersRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->describeCategoryModelMasters(
(new DescribeCategoryModelMastersRequest())
->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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DescribeCategoryModelMastersRequest;
import io.gs2.ranking.result.DescribeCategoryModelMastersResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DescribeCategoryModelMastersResult result = client.describeCategoryModelMasters(
new DescribeCategoryModelMastersRequest()
.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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DescribeCategoryModelMasters(
new Gs2.Gs2Ranking.Request.DescribeCategoryModelMastersRequest()
.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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.describeCategoryModelMasters(
new Gs2Ranking.DescribeCategoryModelMastersRequest()
.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 ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.describe_category_model_masters(
ranking.DescribeCategoryModelMastersRequest()
.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('ranking')
api_result = client.describe_category_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('ranking')
api_result_handler = client.describe_category_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;
```
---
### createCategoryModelMaster
카테고리 모델 마스터 신규 작성
스코어 범위, 정렬 순서, 스코프 타입, 글로벌 랭킹 설정, 엔트리/액세스 기간 이벤트 설정을 가진 새로운 카테고리 모델 마스터를 작성합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| name | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 점수 최솟값
이 카테고리에 등록할 수 있는 점수의 최솟값입니다.
이 임곗값보다 낮은 점수는 등록 시 거부됩니다. 설정하지 않으면 하한이 없습니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 점수 최댓값
이 카테고리에 등록할 수 있는 점수의 최댓값입니다.
이 임곗값보다 높은 점수는 등록 시 거부됩니다. 설정하지 않으면 상한이 없습니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓| | | 정렬 방향
랭킹 집계의 정렬 순서를 결정합니다.
"asc"(오름차순)는 낮은 점수를 상위로 하며, 시간 기반이나 골프식 랭킹에 적합합니다.
"desc"(내림차순)는 높은 점수를 상위로 하며, 포인트 기반이나 하이스코어 랭킹에 적합합니다.asc: 오름차순 / desc: 내림차순 / |
| scope | 문자열 열거형
enum {
"global",
"scoped"
}
| | ✓| | | 랭킹 종류
이 카테고리의 랭킹 타입입니다.
"global" 은 모든 플레이어가 공유하는 단일 리더보드를 만들며, 설정된 간격으로 배치 집계됩니다.
"scoped" 는 구독한 플레이어(친구나 길드 멤버 등)를 기반으로 한 사용자별 리더보드를 만들며, 점수가 실시간으로 반영됩니다.global: 글로벌 / scoped: 스코프 / |
| globalRankingSetting | [GlobalRankingSetting](#globalrankingsetting) | {scope} == "global" | ✓※| | | 글로벌 랭킹 설정
글로벌 랭킹 모드 전용 설정입니다. 집계 간격, 고정 시각, 점수의 유니크 여부, 세대 관리, 추가 기간 한정 스코프를 포함합니다.
scope 가 "global" 로 설정된 경우에만 적용됩니다.
※ scope이(가) "global" 이면 필수 |
| entryPeriodEventId | string | | | | ~ 1024자 | 점수 등록 기간 이벤트 ID
점수 등록을 받는 기간을 정의하는 GS2-Schedule 이벤트의 GRN입니다.
이 기간 외의 점수 등록 요청은 거부됩니다. 설정하지 않으면 점수는 언제든지 등록할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 접근 기간 이벤트 ID
랭킹 데이터를 열람할 수 있는 기간을 정의하는 GS2-Schedule 이벤트의 GRN입니다.
이 기간 외의 랭킹 조회 요청은 거부됩니다. 설정하지 않으면 랭킹은 언제든지 접근할 수 있습니다. |
| sum | bool | | | false | | 합산 모드
활성화하면 새로 등록된 점수가 기존 점수를 대체하는 것이 아니라 합계에 더해집니다.
랭킹은 누적된 합계값을 기준으로 계산됩니다. 비활성화된 경우 각 점수 등록은 독립된 항목으로 처리됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | 작성한 카테고리 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.CreateCategoryModelMaster(
&ranking.CreateCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
Name: pointy.String("category-0001"),
Description: nil,
Metadata: nil,
MinimumValue: nil,
MaximumValue: nil,
OrderDirection: pointy.String("asc"),
Scope: pointy.String("global"),
GlobalRankingSetting: &ranking.GlobalRankingSetting{
CalculateIntervalMinutes: pointy.Int32(15),
UniqueByUserId: pointy.Bool(false),
AdditionalScopes: []ranking.Scope{
ranking.Scope{
Name: pointy.String("daily"),
TargetDays: pointy.Int64(1),
},
ranking.Scope{
Name: pointy.String("weekly"),
TargetDays: pointy.Int64(7),
},
},
},
EntryPeriodEventId: nil,
AccessPeriodEventId: nil,
Sum: 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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\CreateCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->createCategoryModelMaster(
(new CreateCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withName("category-0001")
->withDescription(null)
->withMetadata(null)
->withMinimumValue(null)
->withMaximumValue(null)
->withOrderDirection("asc")
->withScope("global")
->withGlobalRankingSetting((new \Gs2\Ranking\Model\GlobalRankingSetting())
->withCalculateIntervalMinutes(15)
->withUniqueByUserId(false)
->withAdditionalScopes([
(new \Gs2\Ranking\Model\Scope())
->withName("daily")
->withTargetDays(1),
(new \Gs2\Ranking\Model\Scope())
->withName("weekly")
->withTargetDays(7),
]))
->withEntryPeriodEventId(null)
->withAccessPeriodEventId(null)
->withSum(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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.CreateCategoryModelMasterRequest;
import io.gs2.ranking.result.CreateCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
CreateCategoryModelMasterResult result = client.createCategoryModelMaster(
new CreateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("category-0001")
.withDescription(null)
.withMetadata(null)
.withMinimumValue(null)
.withMaximumValue(null)
.withOrderDirection("asc")
.withScope("global")
.withGlobalRankingSetting(new io.gs2.ranking.model.GlobalRankingSetting()
.withCalculateIntervalMinutes(15)
.withUniqueByUserId(false)
.withAdditionalScopes(Arrays.asList(
new io.gs2.ranking.model.Scope()
.withName("daily")
.withTargetDays(1L),
new io.gs2.ranking.model.Scope()
.withName("weekly")
.withTargetDays(7L)
)))
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
.withSum(null)
);
CategoryModelMaster 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.CreateCategoryModelMaster(
new Gs2.Gs2Ranking.Request.CreateCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithName("category-0001")
.WithDescription(null)
.WithMetadata(null)
.WithMinimumValue(null)
.WithMaximumValue(null)
.WithOrderDirection("asc")
.WithScope("global")
.WithGlobalRankingSetting(new Gs2.Gs2Ranking.Model.GlobalRankingSetting()
.WithCalculateIntervalMinutes(15)
.WithUniqueByUserId(false)
.WithAdditionalScopes(new Gs2.Gs2Ranking.Model.Scope[] {
new Gs2.Gs2Ranking.Model.Scope()
.WithName("daily")
.WithTargetDays(1L),
new Gs2.Gs2Ranking.Model.Scope()
.WithName("weekly")
.WithTargetDays(7L),
}))
.WithEntryPeriodEventId(null)
.WithAccessPeriodEventId(null)
.WithSum(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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.createCategoryModelMaster(
new Gs2Ranking.CreateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withName("category-0001")
.withDescription(null)
.withMetadata(null)
.withMinimumValue(null)
.withMaximumValue(null)
.withOrderDirection("asc")
.withScope("global")
.withGlobalRankingSetting(new Gs2Ranking.model.GlobalRankingSetting()
.withCalculateIntervalMinutes(15)
.withUniqueByUserId(false)
.withAdditionalScopes([
new Gs2Ranking.model.Scope()
.withName("daily")
.withTargetDays(1),
new Gs2Ranking.model.Scope()
.withName("weekly")
.withTargetDays(7),
]))
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
.withSum(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.create_category_model_master(
ranking.CreateCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_name('category-0001')
.with_description(None)
.with_metadata(None)
.with_minimum_value(None)
.with_maximum_value(None)
.with_order_direction('asc')
.with_scope('global')
.with_global_ranking_setting(
ranking.GlobalRankingSetting()
.with_calculate_interval_minutes(15)
.with_unique_by_user_id(False)
.with_additional_scopes([
ranking.Scope()
.with_name('daily')
.with_target_days(1),
ranking.Scope()
.with_name('weekly')
.with_target_days(7),
]))
.with_entry_period_event_id(None)
.with_access_period_event_id(None)
.with_sum(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.create_category_model_master({
namespaceName="namespace-0001",
name="category-0001",
description=nil,
metadata=nil,
minimumValue=nil,
maximumValue=nil,
orderDirection="asc",
scope="global",
globalRankingSetting={
calculateIntervalMinutes=15,
uniqueByUserId=false,
additionalScopes={
{
name="daily",
targetDays=1,
},
{
name="weekly",
targetDays=7,
}
},
},
entryPeriodEventId=nil,
accessPeriodEventId=nil,
sum=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('ranking')
api_result_handler = client.create_category_model_master_async({
namespaceName="namespace-0001",
name="category-0001",
description=nil,
metadata=nil,
minimumValue=nil,
maximumValue=nil,
orderDirection="asc",
scope="global",
globalRankingSetting={
calculateIntervalMinutes=15,
uniqueByUserId=false,
additionalScopes={
{
name="daily",
targetDays=1,
},
{
name="weekly",
targetDays=7,
}
},
},
entryPeriodEventId=nil,
accessPeriodEventId=nil,
sum=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;
```
---
### getCategoryModelMaster
카테고리 모델 마스터 취득
지정된 카테고리 모델 마스터를 취득합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | 카테고리 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.GetCategoryModelMaster(
&ranking.GetCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\GetCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->getCategoryModelMaster(
(new GetCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.GetCategoryModelMasterRequest;
import io.gs2.ranking.result.GetCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
GetCategoryModelMasterResult result = client.getCategoryModelMaster(
new GetCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
CategoryModelMaster 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.GetCategoryModelMaster(
new Gs2.Gs2Ranking.Request.GetCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.getCategoryModelMaster(
new Gs2Ranking.GetCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.get_category_model_master(
ranking.GetCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.get_category_model_master({
namespaceName="namespace-0001",
categoryName="category-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('ranking')
api_result_handler = client.get_category_model_master_async({
namespaceName="namespace-0001",
categoryName="category-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;
```
---
### updateCategoryModelMaster
카테고리 모델 마스터 갱신
지정된 카테고리 모델 마스터의 스코어 범위, 정렬 순서, 스코프 타입, 글로벌 랭킹 설정, 엔트리/액세스 기간 이벤트 설정을 갱신합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| description | string | | | | ~ 1024자 | 설명문 |
| metadata | string | | | | ~ 1024자 | 메타데이터
메타데이터에는 임의의 값을 설정할 수 있습니다.
이 값들은 GS2의 동작에는 영향을 주지 않으므로, 게임 내에서 사용하는 정보를 저장하는 용도로 사용할 수 있습니다. |
| minimumValue | long | | | | 0 ~ 9223372036854775805 | 점수 최솟값
이 카테고리에 등록할 수 있는 점수의 최솟값입니다.
이 임곗값보다 낮은 점수는 등록 시 거부됩니다. 설정하지 않으면 하한이 없습니다. |
| maximumValue | long | | | | 0 ~ 9223372036854775805 | 점수 최댓값
이 카테고리에 등록할 수 있는 점수의 최댓값입니다.
이 임곗값보다 높은 점수는 등록 시 거부됩니다. 설정하지 않으면 상한이 없습니다. |
| orderDirection | 문자열 열거형
enum {
"asc",
"desc"
}
| | ✓| | | 정렬 방향
랭킹 집계의 정렬 순서를 결정합니다.
"asc"(오름차순)는 낮은 점수를 상위로 하며, 시간 기반이나 골프식 랭킹에 적합합니다.
"desc"(내림차순)는 높은 점수를 상위로 하며, 포인트 기반이나 하이스코어 랭킹에 적합합니다.asc: 오름차순 / desc: 내림차순 / |
| scope | 문자열 열거형
enum {
"global",
"scoped"
}
| | ✓| | | 랭킹 종류
이 카테고리의 랭킹 타입입니다.
"global" 은 모든 플레이어가 공유하는 단일 리더보드를 만들며, 설정된 간격으로 배치 집계됩니다.
"scoped" 는 구독한 플레이어(친구나 길드 멤버 등)를 기반으로 한 사용자별 리더보드를 만들며, 점수가 실시간으로 반영됩니다.global: 글로벌 / scoped: 스코프 / |
| globalRankingSetting | [GlobalRankingSetting](#globalrankingsetting) | {scope} == "global" | ✓※| | | 글로벌 랭킹 설정
글로벌 랭킹 모드 전용 설정입니다. 집계 간격, 고정 시각, 점수의 유니크 여부, 세대 관리, 추가 기간 한정 스코프를 포함합니다.
scope 가 "global" 로 설정된 경우에만 적용됩니다.
※ scope이(가) "global" 이면 필수 |
| entryPeriodEventId | string | | | | ~ 1024자 | 점수 등록 기간 이벤트 ID
점수 등록을 받는 기간을 정의하는 GS2-Schedule 이벤트의 GRN입니다.
이 기간 외의 점수 등록 요청은 거부됩니다. 설정하지 않으면 점수는 언제든지 등록할 수 있습니다. |
| accessPeriodEventId | string | | | | ~ 1024자 | 접근 기간 이벤트 ID
랭킹 데이터를 열람할 수 있는 기간을 정의하는 GS2-Schedule 이벤트의 GRN입니다.
이 기간 외의 랭킹 조회 요청은 거부됩니다. 설정하지 않으면 랭킹은 언제든지 접근할 수 있습니다. |
| sum | bool | | | false | | 합산 모드
활성화하면 새로 등록된 점수가 기존 점수를 대체하는 것이 아니라 합계에 더해집니다.
랭킹은 누적된 합계값을 기준으로 계산됩니다. 비활성화된 경우 각 점수 등록은 독립된 항목으로 처리됩니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | 갱신한 카테고리 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.UpdateCategoryModelMaster(
&ranking.UpdateCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-0001"),
Description: pointy.String("description1"),
Metadata: pointy.String("CATEGORY_0001"),
MinimumValue: pointy.Int64(100),
MaximumValue: pointy.Int64(10000),
OrderDirection: pointy.String("desc"),
Scope: pointy.String("global"),
GlobalRankingSetting: &ranking.GlobalRankingSetting{
CalculateIntervalMinutes: pointy.Int32(15),
UniqueByUserId: pointy.Bool(true),
AdditionalScopes: []ranking.Scope{
ranking.Scope{
Name: pointy.String("weekly"),
TargetDays: pointy.Int64(7),
},
ranking.Scope{
Name: pointy.String("monthly"),
TargetDays: pointy.Int64(30),
},
},
},
EntryPeriodEventId: nil,
AccessPeriodEventId: nil,
Sum: 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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\UpdateCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->updateCategoryModelMaster(
(new UpdateCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-0001")
->withDescription("description1")
->withMetadata("CATEGORY_0001")
->withMinimumValue(100)
->withMaximumValue(10000)
->withOrderDirection("desc")
->withScope("global")
->withGlobalRankingSetting((new \Gs2\Ranking\Model\GlobalRankingSetting())
->withCalculateIntervalMinutes(15)
->withUniqueByUserId(true)
->withAdditionalScopes([
(new \Gs2\Ranking\Model\Scope())
->withName("weekly")
->withTargetDays(7),
(new \Gs2\Ranking\Model\Scope())
->withName("monthly")
->withTargetDays(30),
]))
->withEntryPeriodEventId(null)
->withAccessPeriodEventId(null)
->withSum(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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.UpdateCategoryModelMasterRequest;
import io.gs2.ranking.result.UpdateCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
UpdateCategoryModelMasterResult result = client.updateCategoryModelMaster(
new UpdateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withDescription("description1")
.withMetadata("CATEGORY_0001")
.withMinimumValue(100L)
.withMaximumValue(10000L)
.withOrderDirection("desc")
.withScope("global")
.withGlobalRankingSetting(new io.gs2.ranking.model.GlobalRankingSetting()
.withCalculateIntervalMinutes(15)
.withUniqueByUserId(true)
.withAdditionalScopes(Arrays.asList(
new io.gs2.ranking.model.Scope()
.withName("weekly")
.withTargetDays(7L),
new io.gs2.ranking.model.Scope()
.withName("monthly")
.withTargetDays(30L)
)))
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
.withSum(null)
);
CategoryModelMaster 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.UpdateCategoryModelMaster(
new Gs2.Gs2Ranking.Request.UpdateCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-0001")
.WithDescription("description1")
.WithMetadata("CATEGORY_0001")
.WithMinimumValue(100L)
.WithMaximumValue(10000L)
.WithOrderDirection("desc")
.WithScope("global")
.WithGlobalRankingSetting(new Gs2.Gs2Ranking.Model.GlobalRankingSetting()
.WithCalculateIntervalMinutes(15)
.WithUniqueByUserId(true)
.WithAdditionalScopes(new Gs2.Gs2Ranking.Model.Scope[] {
new Gs2.Gs2Ranking.Model.Scope()
.WithName("weekly")
.WithTargetDays(7L),
new Gs2.Gs2Ranking.Model.Scope()
.WithName("monthly")
.WithTargetDays(30L),
}))
.WithEntryPeriodEventId(null)
.WithAccessPeriodEventId(null)
.WithSum(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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.updateCategoryModelMaster(
new Gs2Ranking.UpdateCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
.withDescription("description1")
.withMetadata("CATEGORY_0001")
.withMinimumValue(100)
.withMaximumValue(10000)
.withOrderDirection("desc")
.withScope("global")
.withGlobalRankingSetting(new Gs2Ranking.model.GlobalRankingSetting()
.withCalculateIntervalMinutes(15)
.withUniqueByUserId(true)
.withAdditionalScopes([
new Gs2Ranking.model.Scope()
.withName("weekly")
.withTargetDays(7),
new Gs2Ranking.model.Scope()
.withName("monthly")
.withTargetDays(30),
]))
.withEntryPeriodEventId(null)
.withAccessPeriodEventId(null)
.withSum(null)
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.update_category_model_master(
ranking.UpdateCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
.with_description('description1')
.with_metadata('CATEGORY_0001')
.with_minimum_value(100)
.with_maximum_value(10000)
.with_order_direction('desc')
.with_scope('global')
.with_global_ranking_setting(
ranking.GlobalRankingSetting()
.with_calculate_interval_minutes(15)
.with_unique_by_user_id(True)
.with_additional_scopes([
ranking.Scope()
.with_name('weekly')
.with_target_days(7),
ranking.Scope()
.with_name('monthly')
.with_target_days(30),
]))
.with_entry_period_event_id(None)
.with_access_period_event_id(None)
.with_sum(None)
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.update_category_model_master({
namespaceName="namespace-0001",
categoryName="category-0001",
description="description1",
metadata="CATEGORY_0001",
minimumValue=100,
maximumValue=10000,
orderDirection="desc",
scope="global",
globalRankingSetting={
calculateIntervalMinutes=15,
uniqueByUserId=true,
additionalScopes={
{
name="weekly",
targetDays=7,
},
{
name="monthly",
targetDays=30,
}
},
},
entryPeriodEventId=nil,
accessPeriodEventId=nil,
sum=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('ranking')
api_result_handler = client.update_category_model_master_async({
namespaceName="namespace-0001",
categoryName="category-0001",
description="description1",
metadata="CATEGORY_0001",
minimumValue=100,
maximumValue=10000,
orderDirection="desc",
scope="global",
globalRankingSetting={
calculateIntervalMinutes=15,
uniqueByUserId=true,
additionalScopes={
{
name="weekly",
targetDays=7,
},
{
name="monthly",
targetDays=30,
}
},
},
entryPeriodEventId=nil,
accessPeriodEventId=nil,
sum=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;
```
---
### deleteCategoryModelMaster
카테고리 모델 마스터 삭제
지정된 카테고리 모델 마스터를 삭제합니다.
#### Request
| | 타입 | 활성화 조건 | 필수 | 기본값 | 값 제한 | 설명 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128자 | 네임스페이스 이름
네임스페이스 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
| categoryName | string | | ✓| | ~ 128자 | 카테고리 모델 이름
카테고리 모델 고유의 이름입니다. 영숫자 및 -(하이픈) _(언더스코어) .(마침표)로 지정합니다. |
#### Result
| | 타입 | 설명 |
| --- | --- | --- |
| item | [CategoryModelMaster](#categorymodelmaster) | 삭제한 카테고리 모델 마스터 |
#### 구현 예제
**Go**
```go
import "github.com/gs2io/gs2-golang-sdk/core"
import "github.com/gs2io/gs2-golang-sdk/ranking"
import "github.com/openlyinc/pointy"
session := core.Gs2RestSession{
Credential: &core.BasicGs2Credential{
ClientId: "your client id",
ClientSecret: "your client secret",
},
Region: core.ApNortheast1,
}
if err := session.Connect(); err != nil {
panic("error occurred")
}
client := ranking.Gs2RankingRestClient{
Session: &session,
}
result, err := client.DeleteCategoryModelMaster(
&ranking.DeleteCategoryModelMasterRequest {
NamespaceName: pointy.String("namespace-0001"),
CategoryName: pointy.String("category-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\Ranking\Gs2RankingRestClient;
use Gs2\Ranking\Request\DeleteCategoryModelMasterRequest;
$session = new Gs2RestSession(
new BasicGs2Credential(
"your client id",
"your client secret"
),
Region::AP_NORTHEAST_1
);
$session->open();
$client = new Gs2RankingRestClient(
$session
);
try {
$result = $client->deleteCategoryModelMaster(
(new DeleteCategoryModelMasterRequest())
->withNamespaceName("namespace-0001")
->withCategoryName("category-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.ranking.rest.Gs2RankingRestClient;
import io.gs2.ranking.request.DeleteCategoryModelMasterRequest;
import io.gs2.ranking.result.DeleteCategoryModelMasterResult;
Gs2RestSession session = new Gs2RestSession(
Region.AP_NORTHEAST_1,
new BasicGs2Credential(
"your client id",
"your client secret"
)
);
session.connect();
Gs2RankingRestClient client = new Gs2RankingRestClient(session);
try {
DeleteCategoryModelMasterResult result = client.deleteCategoryModelMaster(
new DeleteCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
CategoryModelMaster 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 Gs2RankingRestClient(session);
AsyncResult asyncResult = null;
yield return client.DeleteCategoryModelMaster(
new Gs2.Gs2Ranking.Request.DeleteCategoryModelMasterRequest()
.WithNamespaceName("namespace-0001")
.WithCategoryName("category-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 Gs2Ranking from '@/gs2/ranking';
const session = new Gs2Core.Gs2RestSession(
"ap-northeast-1",
new Gs2Core.BasicGs2Credential(
'your client id',
'your client secret'
)
);
await session.connect();
const client = new Gs2Ranking.Gs2RankingRestClient(session);
try {
const result = await client.deleteCategoryModelMaster(
new Gs2Ranking.DeleteCategoryModelMasterRequest()
.withNamespaceName("namespace-0001")
.withCategoryName("category-0001")
);
const item = result.getItem();
} catch (e) {
process.exit(1);
}
```
**Python**
```python
from gs2 import core
from gs2 import ranking
session = core.Gs2RestSession(
core.BasicGs2Credential(
'your client id',
'your client secret'
),
"ap-northeast-1",
)
session.connect()
client = ranking.Gs2RankingRestClient(session)
try:
result = client.delete_category_model_master(
ranking.DeleteCategoryModelMasterRequest()
.with_namespace_name('namespace-0001')
.with_category_name('category-0001')
)
item = result.item
except core.Gs2Exception as e:
exit(1)
```
**GS2-Script**
```lua
client = gs2('ranking')
api_result = client.delete_category_model_master({
namespaceName="namespace-0001",
categoryName="category-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('ranking')
api_result_handler = client.delete_category_model_master_async({
namespaceName="namespace-0001",
categoryName="category-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;
```
---