ripple-api/app/v1/score.go

291 lines
7.0 KiB
Go

package v1
import (
"database/sql"
"encoding/json"
"fmt"
"strconv"
"strings"
"gopkg.in/thehowl/go-osuapi.v1"
"github.com/osuYozora/api/common"
"zxq.co/x/getrank"
)
// Score is a score done on Ripple.
type Score struct {
ID int `json:"id"`
BeatmapMD5 string `json:"beatmap_md5"`
Score int64 `json:"score"`
MaxCombo int `json:"max_combo"`
FullCombo bool `json:"full_combo"`
Mods int `json:"mods"`
Count300 int `json:"count_300"`
Count100 int `json:"count_100"`
Count50 int `json:"count_50"`
CountGeki int `json:"count_geki"`
CountKatu int `json:"count_katu"`
CountMiss int `json:"count_miss"`
Time common.UnixTimestamp `json:"time"`
PlayMode int `json:"play_mode"`
Accuracy float64 `json:"accuracy"`
PP float32 `json:"pp"`
Rank string `json:"rank"`
Completed int `json:"completed"`
}
// beatmapScore is to differentiate from userScore, as beatmapScore contains
// also an user, while userScore contains the beatmap.
type beatmapScore struct {
Score
User userData `json:"user"`
}
type scoresResponse struct {
common.ResponseBase
Scores []beatmapScore `json:"scores"`
}
// ScoresGET retrieves the top scores for a certain beatmap.
func ScoresGET(md common.MethodData) common.CodeMessager {
var (
where = new(common.WhereClause)
r scoresResponse
)
pm := md.Ctx.Request.URI().QueryArgs().PeekMulti
switch {
case md.Query("md5") != "":
where.In("beatmap_md5", pm("md5")...)
case md.Query("b") != "":
var md5 string
err := md.DB.Get(&md5, "SELECT beatmap_md5 FROM beatmaps WHERE beatmap_id = ? LIMIT 1", md.Query("b"))
switch {
case err == sql.ErrNoRows:
r.Code = 200
return r
case err != nil:
md.Err(err)
return Err500
}
where.Where("beatmap_md5 = ?", md5)
}
where.In("scores.id", pm("id")...)
sort := common.Sort(md, common.SortConfiguration{
Default: "scores.pp DESC, scores.score DESC",
Table: "scores",
Allowed: []string{"pp", "score", "accuracy", "id"},
})
if where.Clause == "" {
return ErrMissingField("must specify at least one queried item")
}
where.Where(` scores.completed = '3' AND `+md.User.OnlyUserPublic(false)+` `+
genModeClause(md)+` `+sort+common.Paginate(md.Query("p"), md.Query("l"), 100), "FIF")
where.Params = where.Params[:len(where.Params)-1]
rows, err := md.DB.Query(`
SELECT
scores.id, scores.beatmap_md5, scores.score,
scores.max_combo, scores.full_combo, scores.mods,
scores.300_count, scores.100_count, scores.50_count,
scores.gekis_count, scores.katus_count, scores.misses_count,
scores.time, scores.play_mode, scores.accuracy, scores.pp,
scores.completed,
users.id, users.username, users.register_datetime, users.privileges,
users.latest_activity, users_stats.username_aka, users_stats.country
FROM scores
INNER JOIN users ON users.id = scores.userid
INNER JOIN users_stats ON users_stats.id = scores.userid
`+where.Clause, where.Params...)
if err != nil {
md.Err(err)
return Err500
}
for rows.Next() {
var (
s beatmapScore
u userData
)
err := rows.Scan(
&s.ID, &s.BeatmapMD5, &s.Score.Score,
&s.MaxCombo, &s.FullCombo, &s.Mods,
&s.Count300, &s.Count100, &s.Count50,
&s.CountGeki, &s.CountKatu, &s.CountMiss,
&s.Time, &s.PlayMode, &s.Accuracy, &s.PP,
&s.Completed,
&u.ID, &u.Username, &u.RegisteredOn, &u.Privileges,
&u.LatestActivity, &u.UsernameAKA, &u.Country,
)
if err != nil {
md.Err(err)
continue
}
s.User = u
s.Rank = strings.ToUpper(getrank.GetRank(
osuapi.Mode(s.PlayMode),
osuapi.Mods(s.Mods),
s.Accuracy,
s.Count300,
s.Count100,
s.Count50,
s.CountMiss,
))
r.Scores = append(r.Scores, s)
}
r.Code = 200
return r
}
type scoreReportData struct {
ScoreID int `json:"score_id"`
Data json.RawMessage `json:"data"`
Anticheat string `json:"anticheat"`
Severity float32 `json:"severity"`
}
type scoreReport struct {
ID int `json:"id"`
scoreReportData
}
type scoreReportResponse struct {
common.ResponseBase
scoreReport
}
// ScoreReportPOST creates a new report for a score
func ScoreReportPOST(md common.MethodData) common.CodeMessager {
var data scoreReportData
err := md.Unmarshal(&data)
if err != nil {
return ErrBadJSON
}
// Check if there are any missing fields
var missingFields []string
if data.ScoreID == 0 {
missingFields = append(missingFields, "score_id")
}
if data.Anticheat == "" {
missingFields = append(missingFields, "anticheat")
}
if len(missingFields) > 0 {
return ErrMissingField(missingFields...)
}
tx, err := md.DB.Beginx()
if err != nil {
md.Err(err)
return Err500
}
// Get anticheat ID
var id int
err = tx.Get(&id, "SELECT id FROM anticheats WHERE name = ? LIMIT 1", data.Anticheat)
switch err {
case nil: // carry on
case sql.ErrNoRows:
// Create anticheat!
res, err := tx.Exec("INSERT INTO anticheats (name) VALUES (?);", data.Anticheat)
if err != nil {
md.Err(err)
return Err500
}
lid, err := res.LastInsertId()
if err != nil {
md.Err(err)
return Err500
}
id = int(lid)
default:
md.Err(err)
return Err500
}
d := sql.NullString{String: string(data.Data), Valid: true}
if d.String == "null" || d.String == `""` ||
d.String == "[]" || d.String == "{}" || d.String == "0" {
d.Valid = false
}
res, err := tx.Exec("INSERT INTO anticheat_reports (score_id, anticheat_id, data, severity) VALUES (?, ?, ?, ?)",
data.ScoreID, id, d, data.Severity)
if err != nil {
md.Err(err)
return Err500
}
lid, err := res.LastInsertId()
if err != nil {
md.Err(err)
return Err500
}
err = tx.Commit()
if err != nil {
md.Err(err)
return Err500
}
if !d.Valid {
data.Data = json.RawMessage("null")
}
repData := scoreReportResponse{
scoreReport: scoreReport{
ID: int(lid),
scoreReportData: data,
},
}
repData.Code = 200
return repData
}
func getMode(m string) string {
switch m {
case "1":
return "taiko"
case "2":
return "ctb"
case "3":
return "mania"
default:
return "std"
}
}
func genModeClause(md common.MethodData) string {
var modeClause string
if md.Query("mode") != "" {
m, err := strconv.Atoi(md.Query("mode"))
if err == nil && m >= 0 && m <= 3 {
modeClause = fmt.Sprintf("AND scores.play_mode = '%d'", m)
}
}
return modeClause
}
func genModeClauseRx(md common.MethodData) string {
var modeClause string
if md.Query("mode") != "" {
m, err := strconv.Atoi(md.Query("mode"))
if err == nil && m >= 0 && m <= 3 {
modeClause = fmt.Sprintf("AND scores_relax.play_mode = '%d'", m)
}
}
return modeClause
}
func genModeClauseAp(md common.MethodData) string {
var modeClause string
if md.Query("mode") != "" {
m, err := strconv.Atoi(md.Query("mode"))
if err == nil && m >= 0 && m <= 3 {
modeClause = fmt.Sprintf("AND scores_auto.play_mode = '%d'", m)
}
}
return modeClause
}