실시간 랭킹 불러오기

실시간 랭킹을 불러오기 위한 기능들입니다.

정보
  • 실시간 랭킹을 조회할 때 필요한 uuid 값은 RTRankList의 리턴 값이나 콘솔의 해당 실시간 랭킹의 카드에서 확인할 수 있습니다.
  • 실시간 랭킹을 생성하기 전에 UpdateRTRankTable 함수를 이용하여 갱신한 데이터는 해당 실시간 랭킹에 반영되지 않습니다.
  • 유저의 점수를 실시간 랭킹에 등록하기 위해서는 반드시 콘솔에서 실시간 랭킹을 먼저 생성한 후 UpdateRTRankTable 함수를 이용하여 유저의 점수를 갱신해야 합니다.

실시간 랭킹 리스트 불러오기

뒤끝 콘솔에 등록한 모든 실시간 랭킹의 리스트를 불러오는 기능입니다.

동기

RTRankList() -> BackendReturnObject

// example
Backend.RTRank.RTRankList();

비동기

RTRankList( Function callback ) -> void

// example
Backend.RTRank.RTRankList( ( callback ) => 
{
    // 이후 처리
});

결과값 예시

{ 
    rows:
    [
        { 
          date : { S : "초기화 기간"},
          table : { S : "실시간 랭킹에 사용하는 table 명"}
          column : { S : "실시간 랭킹에 사용하는 column 명"},
          reward : { L : []}, // 실시간 랭킹 보상이 존재하지 않는 경우
          inDate : { S : "랭킹 생성 시각"}
          uuid : { S : "랭킹의 uuid"},
          order : { S : "정렬 방법"},
          title : { S : "랭킹 명"},
        },
        { 
          date : { S : "초기화 기간"},
          table : { S : "실시간 랭킹에 사용하는 table 명"}
          column : { S : "실시간 랭킹에 사용하는 column 명"},
          // 실시간 랭킹 보상이 존재하는 경우
          reward : { L : [ M : {
              startRank : { S : "해당 보상을 수령받는 시작 랭킹"},
              endRank : { S : "해당 보상을 수령받는 마지막 랭킹"},
              rewardItems : { M : { "아이템 정보" } }, 
              rewardItemCount : {S : "수령 아이템 갯수"}
            },
            reward : [object]], 
          }, 
          inDate : { S : "랭킹 생성 시각"}
          uuid : { S : "랭킹의 uuid"},
          order : { S : "정렬 방법"},
          title : { S : "랭킹 명"},
        },
        { 
            date: [Object], 
            table: [Object], 
            column: [Object], 
            reward: [Object],
            uuid: [Object], 
            inDate: [Object], 
            order: [Object], 
            title: [Object] 
        },
    ],
}

Return Cases

  • 랭킹이 없는 경우
    statusCode : 200
    message : Success
    returnValue : {"rows":[]}

특정 실시간 랭킹 불러오기

뒤끝 콘솔에 등록한 랭킹의 특정 항목의 값을 가져옵니다. 리스트의 특정 랭킹의 값을 가져오기 위해서는 uuid값이 필요합니다.

동기

GetRTRankByUuid( string rankUuid ) -> BackendReturnObject
GetRTRankByUuid( string rankUuid, int limit ) -> BackendReturnObject
GetRTRankByUuid( string rankUuid, int limit, int offset ) -> BackendReturnObject

// example
Backend.RTRank.GetRTRankByUuid( "uuid" ); // (default) 상위 10명 랭킹 정보 조회 (1-10)
Backend.RTRank.GetRTRankByUuid( "uuid", 2 ); // 상위 2명 랭킹 정보 조회 (1-2)
Backend.RTRank.GetRTRankByUuid( "uuid", 5, 2 ); // 처음 2명 이후의 상위 5명 랭킹 정보 정보 (3-7)

비동기

GetRTRankByUuid( string rankUuid, Function callback ) -> void
GetRTRankByUuid( string rankUuid, int limit, Function callback ) -> void
GetRTRankByUuid( string rankUuid, int limit, int offset, Function callback ) -> void

// example
Backend.RTRank.GetRTRankByUuid( "uuid", ( callback ) => 
{
    // (default) 상위 10명 랭킹 정보 조회 (1-10)
    // 이후 처리
}); 
Backend.RTRank.GetRTRankByUuid( "uuid", 2 , ( callback ) => 
{
    // 상위 2명 랭킹 정보 조회 (1-2)
    // 이후 처리
}); 
Backend.RTRank.GetRTRankByUuid( "uuid", 5, 2, ( callback)  => 
{
    // 처음 2명 이후의 상위 5명 랭킹 정보 정보 (3-7)
    // 이후 처리
}); 

Parameters

ValueTypeDescriptiondefault
uuidStringRTRankList 에서 넘어오는 JsonArray안의 JsonObject uuid의 Value
limitint(Optional) 불러올 랭킹의 수10
offsetint(Optional) 불러올 랭킹의 시작점 (0부터 시작)0

결과값 예시

{ 
    rows:
    [
        { 
            gamer_id: { "9bfbcdb0-b35a-11e9-a6af-c35e0b5e70db" },
            gamerInDate: { "2019-07-31T06:15:35.691Z" },
            nickname: { "thebackend" },
            score: { N: 0 },
            rank: { N: 1 },
        },
        { 
            gamer_id: [string], 
            gamerInDate: [string], 
            nickname: [string], 
            score: [Object], 
            rank: [Object]
        }
    ],
    totalCount: 1,          // 랭킹 집계된 전체 갯수
    type: 'RTScore',        // 랭킹에 사용한 테이블 명
    detailType: 'score',    // 랭킹에 사용한 테이블의 컬럼 명
    period:
    {
        // 기간 없음 랭킹의 경우 startDate, endDate가 존재하지 않고 string으로 infinity 표시
        startDate: '2019-08-29T02:36:30.879Z',
        endDate: '2019-08-29T14:59:59.999Z'
    }
}

Return Cases

  • 랭킹이 없는 경우
    statusCode : 200
    message : Success
    returnValue : {"rows":[],"totalCount":0}

  • 랭킹 Uuid가 틀린 경우
    statusCode : 404
    errorCode : NotFoundException
    message : rank not found, rank을(를) 찾을 수 없습니다

특정 실시간 랭킹에서 플레이어의 랭킹 불러오기

특정 실시간 랭킹에서 게임 유저의 랭킹을 가져옵니다. 게임 유저의 랭킹의 값을 가져오기 위해서는 랭킹의 uuid값이 필요합니다.

동기

GetMyRTRank( String uuid, Int gap = 0 ) -> BackendReturnObject

// example
Backend.RTRank.GetMyRTRank( "uuid" );
Backend.RTRank.GetMyRTRank( "uuid", 3 );

비동기

GetMyRTRank( String uuid, Int gap, Function callback ) -> void

// example
Backend.RTRank.GetMyRTRank( "uuid", 1, ( callback ) => 
{
    // 이후 처리
});

Parameters

ValueTypeDescriptiondefault
uuidStringRankList 에서 넘어오는 JsonArray안의 JsonObject uuid의 Value
gapint(Optional) 게임 유저를 기준으로 출력할 위아래 랭킹의 수0

결과값 예시

{ 
    rows:
    [ 
        { 
            gamerIndate: { "2019-02-18T00:25:47.096Z" },
            nickname: { "thebackend" },
            score: { N: 0 },
            rank: { N: 1 },
            index: { N: 0 },
        }
        { 
            gamerIndate: [string], 
            nickname: [string], 
            score: [Object], 
            rank: [Object], 
            index: [Object] 
        },
    ],
    // 랭킹 집계된 전체 갯수
    totalCount: 1
}

Error case

  • 게이머가 랭킹에 없는 경우
    statusCode : 404
    errorCode : NotFoundException
    message : userRank not found, userRank을(를) 찾을 수 없습니다

특정 실시간 랭킹에서 특정 점수인 유저 불러오기

특정 실시간 랭킹의 특정점수인 유저정보와 해당 점수 위, 아래의 유저정보를 불러옵니다.
게임 유저의 랭킹의 값을 가져오기 위해서는 랭킹의 uuid값이 필요합니다.

동기

GetRTRankByScore( string uuid, int score ) -> BackendReturnObject

// example
Backend.RTRank.GetRTRankByScore( "uuid", 10000 );

비동기

GetRTRankByScore( string uuid, int score, Function callback ) -> void

// example
Backend.RTRank.GetRTRankByScore( "uuid", 10000, ( callback ) => 
{
    // 이후 처리
});

Parameters

ValueTypeDescription
uuidStringRankList 에서 넘어오는 JsonArray안의 JsonObject uuid의 Value
scorelong조회할 점수

결과값 예시

  • 동일한 랭킹점수를 갖고 있는 경우, 해당점수의 모든 게이머정보가 반환됩니다.
  • previousRank/nextRank는 동점의 게이머가 있더라도 한개의 이전/이후 index의 정보만 반환합니다.
  • previousRank/nextRank가 존재하지 않는 경우 gamerIndate나 nickname등의 키 값은 존재하지 않고, NULL이 키 값으로 존재합니다.
  • 해당 점수의 유저가 존재하지 않더라도 previousRank/nextRank는 존재할 수 있습니다.
{ 
    rows:
    [ 
        { 
            gamerIndate: { "2019-02-18T00:25:47.096Z" },
            nickname: { "thebackend" },
            score: { N: 100 },
            rank: { N: 2 },
            index: { N: 0 },
        },
        { 
            gamerIndate: [string], 
            nickname: [string], 
            score: [Object], 
            rank: [Object], 
            index: [Object] 
        }
    ],
    // 해당점수 이전 랭킹의 정보 조회 
    // 존재하지 않는 경우 : previousRank: { NULL: true }
    previousRank: 
    {
        gamerIndate: { "inDate" },
        nickname: { "nickname0" },
        score: { N: 200 },
        rank: { N: 1 },
    },
    // 해당점수 이후 랭킹의 정보 조회
    // 존재하지 않는 경우 : nextRank: { NULL: true },
    nextRank: 
    {
        gamerIndate: { "inDate" },
        nickname: { "nickname1" },
        score: { N: 50 },
        rank: { N: 3 },
    },
    // 랭킹 집계된 전체 갯수
    totalCount: 3
}

Return Cases

  • 해당 점수의 유저가 없는 경우
    statusCode : 200
    message : Success
    returnValue : {"rows":[], "previousRank":{ /유저정보 or NULL/ }, "nextRank":{ /유저정보 or NULL/ }, "totalCount":0}

특정 랭킹의 특정 inDate의 유저정보 불러오기

특정 실시간 랭킹의 특정 gamerInDate로 유저정보를 불러옵니다.
게임 유저의 랭킹의 값을 가져오기 위해서는 랭킹의 uuid값과 해당 유저의 inDate가 필요합니다.

동기

GetRTRankByGamerIndate(string rankUuid, string gamerIndate) -> BackendReturnObject
GetRTRankByGamerIndate(string rankUuid, string gamerIndate, int gap) -> BackendReturnObject

//example
Backend.RTRank.GetRTRankByGamerIndate("rankUuid","gamerIndate");

비동기

GetRTRankByGamerIndate(string rankUuid, string gamerIndate, Function callback) -> void
GetRTRankByGamerIndate(string rankUuid, string gamerIndate, int gap, Function callback) -> void

//example
Backend.Rank.GetRTRankByGamerIndate("rankUuid","gamerIndate", callback =>
{
    //이후 처리

});

Parameters

ValueTypeDescriptiondefault
rankUuidStringRankList 에서 넘어오는 JsonArray안의 JsonObject uuid의 Value
gamerIndateString조회할 유저의 inDate
gapint(Optional) 게임 유저를 기준으로 출력할 위아래 랭킹의 수0
// 해당 inDate의 유저정보 하나만 출력
    rows:
    [ 
        { 
            nickname: { S: "thebackend" },
            score: { N: 9788455 },
            rank: { N: 1 },
            index: { N: 0 },
            gamerIndate: { S: "2019-02-18T00:25:47.096Z" },
            // 랭킹 생성 시 추가 정보를 선택한 경우 (optional) 
            // "S" 혹은 "N" 
        },
    ],
    // 랭킹 집계된 전체 갯수
    totalCount: 100

2. gap이 존재할 경우

//해당 랭킹의 gap만큼 inDate의 유저를 중심으로 위 순위의 랭킹과 아래 순위의 랭킹을 함께 가져옵니다
//유저 닉네임 : test2, inDate :2020-04-13T06:58:19.767Z, gap이 1일 경우
    rows:
    [ 
        { 
            nickname: { S: "test1" },
            score: { N: 101 },
            rank: { N: 5 },
            index: { N: 4 },
            gamerIndate: { S: "2020-04-13T06:58:17.981Z" },
            // 랭킹 생성 시 추가 정보를 선택한 경우 (optional) 
            // "S" 혹은 "N" 
        },
        { 
            nickname: { S: "test2" },
            score: { N: 102 },
            rank: { N: 6 },
            index: { N: 5 },
            gamerIndate: { S: "2020-04-13T06:58:19.767Z" },
        { 
            nickname: { S: "test3" },
            score: { N: 104 },
            rank: { N: 7 },
            index: { N: 6 },
            gamerIndate: { S: "2020-04-13T06:58:21.448Z" },
        },
    ],
    totalCount : 100
    }

Return Cases

  • 랭킹 Uuid가 틀린 경우
    statusCode : 404
    errorCode : NotFoundException
    message : rank not found, rank을(를) 찾을 수 없습니다

  • 존재하지 않는 inDate일 경우
    statusCode : 404
    errorCode : NotFoundException
    message : gamer not found, gamer을(를) 찾을 수 없습니다

  • 랭킹에 해당 inDate의 유저가 등록되어있지 않은 경우
    statusCode : 404
    errorCode : NotFoundException
    message : userRank not found, userRank(를) 찾을 수 없습니다