콘솔

랭킹 불러오기

뒤끝 콘솔에서 테이블의 컬럼(column)을 선택하여 랭킹을 지정하며, 한국시간 06:00, 12:00, 18:00, 24:00을 기준으로 업데이트 됩니다.
랭킹 산출은 랭킹생성 이후 게임정보에 저장된 값만 포함됩니다.

주의
  • 랭킹의 해당하는 게임정보는 한명의 게이머당 하나의 row를 갖도록 update를 해야 중복데이터 발생이 되지 않습니다.
  • 랭킹 정보 업데이트 후, 닉네임이 변경되면 랭킹에 중복 등재될 수 있습니다.

리스트 받아오기

뒤끝 콘솔에 등록한 랭킹의 리스트를 가져옵니다.

동기

RankList ( ) -> BackendReturnObject;

// example
Backend.Rank.RankList();

비동기

RankList ( Function callback ) -> void

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

결과값 예시

{
  rows:
    [
        {
            // 랭킹 산출 기간 (day/week/month/all)
            date: { S : "all" },
            // 랭킹 범위 (column명)
            range: { S : "score" },
            // 랭킹 indate
            inDate: { S : "2018-12-20T02:58:16.052Z" },
            // 랭킹 uuid
            uuid: { S : "18e40340-0403-11e9-bf97-f35e61359527" },
            // 랭킹 정렬 (asc / desc)
            order: { S : "desc" },
            // 랭킹 제목
            title: { S : "러닝타임 시간" },
            // 랭킹 추가정보 column명 (optional)
            extraDataColumn: { S: "extraData" },
            // 랭킹 추가정보 자료형 (optional)
            // "S" 혹은 "N"
            extraDataType: { S: "S" }
        } 
    ]
}

리스트의 특정 랭킹 받아오기

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

동기

GetRankByUuid ( String uuid ) -> BackendReturnObject
GetRankByUuid ( String uuid, int limit ) -> BackendReturnObject
GetRankByUuid ( String uuid, int limit, int offset ) -> BackendReturnObject

// example
Backend.Rank.GetRankByUuid ( json ["rows"] [0] ["uuid"] ["S"] ); // (default) 상위 10명 랭킹 정보 조회 (1-10)
Backend.Rank.GetRankByUuid ( "uuid", 2 ); // 상위 2명 랭킹 정보 조회 (1-2)
Backend.Rank.GetRankByUuid ( "uuid", 5, 2 ); // 처음 2명 이후의 상위 5명 랭킹 정보 정보 (3-7)

비동기

GetRankByUuid ( String uuid, Function callback ) -> void
GetRankByUuid ( String uuid, int limit, Function callback ) -> void
GetRankByUuid ( String uuid, int limit, int offset, Function callback ) -> void

// example
Backend.Rank.GetRankByUuid( json ["rows"] [0] ["uuid"] ["S"], ( callback ) => 
{
    // (default) 상위 10명 랭킹 정보 조회 (1-10)
    // 이후 처리
});
Backend.Rank.GetRankByUuid( "uuid", 2, ( callback ) => 
{ 
    // 상위 2명 랭킹 정보 조회 (1-2)
    // 이후 처리
});
Backend.Rank.GetRankByUuid( "uuid", 5, 2, ( callback ) => 
{
    // 처음 2명 이후의 상위 5명 랭킹 정보 정보 (3-7)
    // 이후 처리
});

Parameters

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

결과값 예시

{ 
    rows:
    [
        { 
            nickname: { S: "thebackend" },
            score: { N: 9788455 },
            rank: { N: 1 },
            index: { N: 0 },
            gamerIndate: { S: "2019-02-18T00:25:47.096Z" },
            // 랭킹 생성 시 추가 정보를 선택한 경우 (optional) 
            // "S" 혹은 "N" 
            extraData: { N: 1234 } 
        },
        { 
            nickname: { S: "jake" },
            score: { N: 9788455 },
            rank: { N: 1 },
            index: { N: 1 },
            gamerIndate: { S: "2019-02-26T02:00:34.943Z" },
            // 랭킹 생성 시 추가 정보를 선택한 경우 (optional) 
            // 해당 게이머의 추가정보 컬럼데이터가 없는 경우
            // "NULL": true
            extraData: { NULL: true } 
        },
        { nickname: [Object], score: [Object], rank: [Object], index: [Object], gamerIndate: [Object], extraData: [Object] },
        { nickname: [Object], score: [Object], rank: [Object], index: [Object], gamerIndate: [Object], extraData: [Object] }
    ],
    // 랭킹 집계된 전체 갯수
    totalCount: 402
}

Return Cases

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

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

특정 랭킹에서 게임 유저 랭킹 받아오기

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

동기

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

// example
Backend.Rank.GetMyRank ( json ["rows"] [0] ["uuid"] ["S"] );
Backend.Rank.GetMyRank ( json ["rows"] [0] ["uuid"] ["S"], 3 );

비동기

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

// example
Backend.Rank.GetMyRank( json ["rows"] [0] ["uuid"] ["S"], 1, ( callback ) => 
{
    // 이후 처리
});

Parameters

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

Error case

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

결과값 예시

{ 
    rows:
    [ 
        { 
            nickname: { S: "thebackend" },
            score: { N: 9788455 },
            rank: { N: 1 },
            index: { N: 0 },
            gamerIndate: { S: "2019-02-18T00:25:47.096Z" },
            // 랭킹 생성 시 추가 정보를 선택한 경우 (optional) 
            // "S" 혹은 "N" 
            extraData: { N: 1234 } 
        },
        { 
            nickname: { S: "jake" },
            score: { N: 9788455 },
            rank: { N: 1 },
            index: { N: 1 },
            gamerIndate: { S: "2019-02-26T02:00:34.943Z" },
            // 랭킹 생성 시 추가 정보를 선택한 경우 (optional) 
            // 해당 게이머의 추가정보 컬럼데이터가 없는 경우
            // "NULL": true
            extraData: { NULL: true } 
        },
        { nickname: [Object], score: [Object], rank: [Object], index: [Object], gamerIndate: [Object], extraData: [Object] },
        { nickname: [Object], score: [Object], rank: [Object], index: [Object], gamerIndate: [Object], extraData: [Object] }
    ],
    // 랭킹 집계된 전체 갯수
    totalCount: 402
}

특정 랭킹의 특정점수인 유저정보 불러오기

특정 랭킹의 특정점수인 유저정보 불러옵니다. 게임 유저의 랭킹의 값을 가져오기 위해서는 랭킹의 uuid값이 필요합니다.

동기

GetRankByScore ( string uuid, int score ) -> BackendReturnObject

// example
Backend.Rank.GetRankByScore ( json ["rows"] [0] ["uuid"] ["S"], 9788455 );

비동기

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

// example
Backend.Rank.GetRankByScore( json ["rows"] [0] ["uuid"] ["S"], 9788455, ( callback ) => 
{
    // 이후 처리
});

Parameters

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

결과값 예시

  • 동일한 랭킹점수를 갖고 있는 경우, 해당점수의 모든 게이머정보가 반환됩니다.
  • previousRank/nextRank는 동점의 게이머가 있더라도 한개의 이전/이후 index의 정보만 반환합니다.

1. 해당 랭킹점수의 게이머와 위, 아래가 있는 경우

{ 
    rows:
    [ 
        { 
            nickname: { S: "thebackend" },
            score: { N: 9788455 },
            rank: { N: 5 },
            index: { N: 6 },
            gamerIndate: { S: "2019-02-18T00:25:47.096Z" },
            // 랭킹 생성 시 추가 정보를 선택한 경우 (optional) 
            // "S" 혹은 "N" 
            extraData: { N: 1234 } 
        },
        { 
            nickname: { S: "jake" },
            score: { N: 9788455 },
            rank: { N: 5 },
            index: { N: 7 },
            gamerIndate: { S: "2019-02-26T02:00:34.943Z" },
            // 랭킹 생성 시 추가 정보를 선택한 경우 (optional) 
            // 해당 게이머의 추가정보 컬럼데이터가 없는 경우
            // "NULL": true
            extraData: { NULL: true } 
        },
        { 
            nickname: [Object],
            score: [Object],
            rank: [Object],
            index: [Object],
            gamerIndate: [Object],
            extraData: [Object]
        }
    ],
    // 해당점수 이전 랭킹의 정보 조회 
    // 존재하지 않는 경우 : previousRank: { NULL: true },
    previousRank: 
    {
        nickname: { S: "id0" },
        gamerIndate: { S: "2019-02-22T00:19:32.980Z" },
        extraData: { NULL: true },
        score: { N: 0 },
        index: { N: 5 },
        rank: { N: 4 }
    },
    // 해당점수 이후 랭킹의 정보 조회
    // 존재하지 않는 경우 : nextRank: { NULL: true },
    nextRank: 
    {
        nickname: { S: "id2" },
        gamerIndate: { S: "2018-11-28T04:43:05.014Z" },
        extraData: { NULL : true },
        score: { N: 42 },
        index: { N: 8 },
        rank: { N: 6 }
    },
    // 랭킹 집계된 전체 갯수
    totalCount: 402
}

2. 해당 랭킹점수의 게이머는 없지만, 위, 아래 게이머가 있는경우

 {
    rows: [ ],
    previousRank: 
    {
        nickname: { S: "id0" },
        gamerIndate: { S: "2019-02-22T00:19:32.980Z" },
        extraData: { NULL: true },
        score: { N: 0 },
        index: { N: 0 },
        rank: { N: 1 }
    },
    nextRank: 
    {
        nickname: { S: "id2" },
        gamerIndate: { S: "2018-11-28T04:43:05.014Z" },
        extraData: { NULL : true },
        score: { N: 42 },
        index: { N: 1 },
        rank: { N: 2 }
    },
    totalCount: 17
}

3. 랭킹에 게이머가 존재하지 않는 경우

{
    rows:[ ],
    previousRank: { NULL: true },
    nextRank: { NULL: true },
    totalCount: 0
}

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

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

동기

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

//example
Backend.Rank.GetRankByGamerIndate("1234-abcd-4567-efg-hijk890","2020-00-10T00:00:00.000Z");

비동기

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

//example
Backend.Rank.GetRankByGamerIndate("1234-abcd-4567-efg-hijk890","2020-00-10T00:00:00.000Z", callback =>
{
    //이후 처리

});

Parameters

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

결과값 예시

1. gap이 없거나 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" 
            extraData: { N: 1234 } 
        },
    ],
    // 랭킹 집계된 전체 갯수
    totalCount: 402

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" 
            extraData: { N: 1234 } 
        },
        { 
            nickname: { S: "test2" },
            score: { N: 102 },
            rank: { N: 6 },
            index: { N: 5 },
            gamerIndate: { S: "2020-04-13T06:58:19.767Z" },
            // 랭킹 생성 시 추가 정보를 선택한 경우 (optional) 
            // 해당 게이머의 추가정보 컬럼데이터가 없는 경우
            // "NULL": true
            extraData: { NULL: true } 
        },
        { 
            nickname: { S: "test3" },
            score: { N: 104 },
            rank: { N: 7 },
            index: { N: 6 },
            gamerIndate: { S: "2020-04-13T06:58:21.448Z" },
            // 랭킹 생성 시 추가 정보를 선택한 경우 (optional) 
            // 해당 게이머의 추가정보 컬럼데이터가 없는 경우
            // "NULL": true
            extraData: { NULL: true } 
        },
    ],
    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(를) 찾을 수 없습니다