Rank design and implement, in progress.

cmd/clean/main.go

@@ -4,13 +4,13 @@ import (
 	"context"
 
 	"github.com/minio/minio-go/v7"
-	casbin_agent "github.com/oj-lab/oj-lab-platform/modules/agent/casbin"
-
 	judge_model "github.com/oj-lab/oj-lab-platform/models/judge"
 	problem_model "github.com/oj-lab/oj-lab-platform/models/problem"
 	user_model "github.com/oj-lab/oj-lab-platform/models/user"
+	casbin_agent "github.com/oj-lab/oj-lab-platform/modules/agent/casbin"
 	gorm_agent "github.com/oj-lab/oj-lab-platform/modules/agent/gorm"
 	minio_agent "github.com/oj-lab/oj-lab-platform/modules/agent/minio"
+	redis_agent "github.com/oj-lab/oj-lab-platform/modules/agent/redis"
 
 	log_module "github.com/oj-lab/oj-lab-platform/modules/log"
 )
@@ -44,6 +44,16 @@ func removeMinioObjects() {
 	log_module.AppLogger().Info("Remove Minio Objects success")
 }
 
+func clearRedis() {
+	ctx := context.Background()
+	redis_agent := redis_agent.GetDefaultRedisClient()
+	err := redis_agent.FlushDB(ctx).Err()
+	if err != nil {
+		log_module.AppLogger().WithError(err).Error("Failed to clear redis")
+	}
+
+	log_module.AppLogger().Info("Clear Redis success")
+}
 func clearDB() {
 	db := gorm_agent.GetDefaultDB()
 
@@ -53,6 +63,8 @@ func clearDB() {
 		&problem_model.ProblemTag{},
 		&judge_model.Judge{},
 		&judge_model.JudgeResult{},
+		&judge_model.JudgeScoreCache{},
+		&judge_model.JudgeRankCache{},
 		"problem_problem_tags",
 		"casbin_rule",
 	)
@@ -61,12 +73,13 @@ func clearDB() {
 		panic("failed to drop tables")
 	}
 
-	log_module.AppLogger().Info("Clear db success")
-
+	log_module.AppLogger().Info("Clear DB success")
 }
+
 func main() {
 	removeMinioObjects()
 	clearCasbin()
+	clearRedis()
 	clearDB()
 
 	println("data clean success")

cmd/init/db.go

@@ -17,6 +17,8 @@ func initDB() {
 		&problem_model.Problem{},
 		&judge_model.Judge{},
 		&judge_model.JudgeResult{},
+		&judge_model.JudgeScoreCache{},
+		&judge_model.JudgeRankCache{},
 	)
 	if err != nil {
 		panic("failed to migrate database")
@@ -36,8 +38,20 @@ func initDB() {
 		Account:  "anonymous",
 		Password: func() *string { s := ""; return &s }(),
 	})
+
 	if err != nil {
 		panic(fmt.Sprintf("failed to create anonymous user: %v", err))
 	}
+
+	_, err = judge_model.CreateJudgeRankCache(db, judge_model.NewJudgeRankCache("root"))
+	if err != nil {
+		panic(fmt.Sprintf("failed to create root rankcache: %v", err))
+	}
+
+	_, err = judge_model.CreateJudgeRankCache(db, judge_model.NewJudgeRankCache("anonymous"))
+	if err != nil {
+		panic(fmt.Sprintf("failed to create anonymous rankcache: %v", err))
+	}
+
 	log_module.AppLogger().Info("migrate tables ans users success")
 }

cmd/web_server/handler/judge_result.go

@@ -80,4 +80,10 @@ func postReportJudgeResult(ginCtx *gin.Context) {
 		gin_utils.NewInternalError(ginCtx, err.Error())
 		return
 	}
+
+	err = judge_service.UpsertJudgeCache(ginCtx, judgeUID, verdict)
+	if err != nil {
+		gin_utils.NewInternalError(ginCtx, err.Error())
+		return
+	}
 }

models/judge/judge_db.go

@@ -21,6 +21,20 @@
 	return &judge, tx.Create(&judge).Error
 }
 
+// only count if when accept && accept time < SolvedTime
+func GetBeforeSubmission(tx *gorm.DB, judge Judge) (int64, error) {
+	var count int64
+	err := tx.Model(&Judge{}).
+		Where("create_at < ?", judge.CreateAt).
+		Where("status = ?", JudgeStatusFinished).
+		Count(&count).Error
+
+	if err != nil {
+		return 0, err
+	}
+	return count + 1, err
+}
+
 func GetJudge(tx *gorm.DB, uid uuid.UUID) (*Judge, error) {
 	judge := Judge{}
 	err := tx.Model(&Judge{}).

models/judge/judge_rank_cache.go

@@ -0,0 +1,23 @@
+package judge_model
+
+import (
+	"github.com/oj-lab/oj-lab-platform/models"
+	user_model "github.com/oj-lab/oj-lab-platform/models/user"
+)
+
+// user contest summary rank info
+type JudgeRankCache struct {
+	models.MetaFields
+	UserAccount      string          `json:"userAccount" gorm:"primaryKey"`
+	User             user_model.User `json:"user"`
+	Points           int64           `json:"points"`
+	TotalSubmissions int64           `json:"totalSubmissions"`
+}
+
+func NewJudgeRankCache(userAccount string) JudgeRankCache {
+	return JudgeRankCache{
+		UserAccount:      userAccount,
+		Points:           0,
+		TotalSubmissions: 0,
+	}
+}

models/judge/judge_rank_cache_db.go

@@ -0,0 +1,26 @@
+package judge_model
+
+import (
+	"github.com/oj-lab/oj-lab-platform/models"
+	"gorm.io/gorm"
+)
+
+func CreateJudgeRankCache(tx *gorm.DB, rankCache JudgeRankCache) (*JudgeRankCache, error) {
+	rankCache.MetaFields = models.NewMetaFields()
+	return &rankCache, tx.Create(&rankCache).Error
+}
+
+func GetJudgeRankCache(tx *gorm.DB, userAccount string) (*JudgeRankCache, error) {
+	rankCache := JudgeRankCache{}
+	err := tx.Model(&JudgeRankCache{}).
+		Where("user_account = ?", userAccount).
+		First(&rankCache).Error
+	if err != nil {
+		return nil, err
+	}
+	return &rankCache, nil
+}
+
+func UpdateJudgeRankCache(tx *gorm.DB, rankCache JudgeRankCache) error {
+	return tx.Model(&rankCache).Updates(rankCache).Error
+}

models/judge/judge_score_cache.go

@@ -0,0 +1,30 @@
+package judge_model
+
+import (
+	"time"
+
+	"github.com/oj-lab/oj-lab-platform/models"
+	problem_model "github.com/oj-lab/oj-lab-platform/models/problem"
+	user_model "github.com/oj-lab/oj-lab-platform/models/user"
+)
+
+// user contest problem summary score info
+type JudgeScoreCache struct {
+	models.MetaFields
+	UserAccount     string                `json:"userAccount" gorm:"primaryKey"`
+	User            user_model.User       `json:"user"`
+	ProblemSlug     string                `json:"problemSlug" gorm:"primaryKey"`
+	Problem         problem_model.Problem `json:"problem"`
+	SubmissionCount int64                 `json:"submissionCount" gorm:"default:1"` // judge create time < solvetime will be count
+	IsAccepted      bool                  `json:"isAccepted" gorm:"default:false"`
+	SolveTime       *time.Time            `json:"solveAt"  gorm:"default:null"` // ac time < solveTime, update submissionCount
+}
+
+func NewJudgeScoreCache(userAccount string, problemSlug string) JudgeScoreCache {
+	return JudgeScoreCache{
+		UserAccount:     userAccount,
+		ProblemSlug:     problemSlug,
+		SubmissionCount: 1,
+		IsAccepted:      false,
+	}
+}

models/judge/judge_score_cache_db.go

@@ -0,0 +1,27 @@
+package judge_model
+
+import (
+	"github.com/oj-lab/oj-lab-platform/models"
+	"gorm.io/gorm"
+)
+
+func CreateJudgeScoreCache(tx *gorm.DB, scoreCache JudgeScoreCache) (*JudgeScoreCache, error) {
+	scoreCache.MetaFields = models.NewMetaFields()
+	return &scoreCache, tx.Create(&scoreCache).Error
+}
+
+func GetJudgeScoreCache(tx *gorm.DB, userAccount string, problemSlug string) (*JudgeScoreCache, error) {
+	scoreCache := JudgeScoreCache{}
+	err := tx.Model(&JudgeScoreCache{}).
+		Where("user_account = ?", userAccount).
+		Where("problem_slug = ?", problemSlug).
+		First(&scoreCache).Error
+	if err != nil {
+		return nil, err
+	}
+	return &scoreCache, nil
+}
+
+func UpdateJudgeScoreCache(tx *gorm.DB, scoreCache JudgeScoreCache) error {
+	return tx.Model(&scoreCache).Updates(scoreCache).Error
+}

models/judge/judge_test.go

@@ -3,8 +3,10 @@ package judge_model
 import (
 	"encoding/json"
 	"testing"
+	"time"
 
 	problem_model "github.com/oj-lab/oj-lab-platform/models/problem"
+	user_model "github.com/oj-lab/oj-lab-platform/models/user"
 	gorm_agent "github.com/oj-lab/oj-lab-platform/modules/agent/gorm"
 )
 
@@ -46,3 +48,50 @@ func TestJudgeDB(t *testing.T) {
 	}
 	t.Logf("%+v\n", string(judgeJson))
 }
+
+func TestJudgeScoreCacheDB(t *testing.T) {
+	db := gorm_agent.GetDefaultDB()
+
+	problem := &problem_model.Problem{
+		Slug: "test-judgeScoreCache-db-problem",
+	}
+	var err error
+	err = problem_model.CreateProblem(db, *problem)
+	if err != nil {
+		t.Error(err)
+	}
+
+	user := &user_model.User{
+		Account: "test-judgeScoreCache-db-user",
+	}
+	_, err = user_model.CreateUser(db, *user)
+	if err != nil {
+		t.Error(err)
+	}
+
+	judgeScoreCache := NewJudgeScoreCache(user.Account, problem.Slug)
+	_, err = CreateJudgeScoreCache(db, judgeScoreCache)
+	if err != nil {
+		t.Error(err)
+	}
+
+	now := time.Now()
+	judgeScoreCache.IsAccepted = true
+	judgeScoreCache.SolveTime = &now
+	judgeScoreCache.SubmissionCount = 10
+	err = UpdateJudgeScoreCache(db, judgeScoreCache)
+	if err != nil {
+		t.Error(err)
+	}
+
+	newjudgeScoreCache, err := GetJudgeScoreCache(db, user.Account, problem.Slug)
+	if err != nil {
+		t.Error(err)
+	}
+
+	judgeScoreCacheJson, err := json.MarshalIndent(newjudgeScoreCache, "", "\t")
+	if err != nil {
+		t.Error(err)
+	}
+	t.Logf("%+v\n", string(judgeScoreCacheJson))
+}

services/judge/judge_cache.go

@@ -0,0 +1,90 @@
+package judge_service
+
+import (
+	"context"
+
+	"github.com/google/uuid"
+	judge_model "github.com/oj-lab/oj-lab-platform/models/judge"
+	gorm_agent "github.com/oj-lab/oj-lab-platform/modules/agent/gorm"
+)
+
+func UpsertJudgeCache(ctx context.Context, uid uuid.UUID, verdict judge_model.JudgeVerdict) error {
+	db := gorm_agent.GetDefaultDB()
+	judge, err := judge_model.GetJudge(db, uid)
+	if err != nil {
+		return err
+	}
+	// log_module.AppLogger().WithField("judge", judge).Debug("getjudge")
+	var scoreCache *judge_model.JudgeScoreCache
+	var rankCache *judge_model.JudgeRankCache
+	rankCache, err = judge_model.GetJudgeRankCache(db, judge.UserAccount)
+	if err != nil {
+		return err
+	}
+
+	extraPoint := 0
+	for {
+		scoreCache, err = judge_model.GetJudgeScoreCache(db, judge.UserAccount, judge.ProblemSlug)
+		if err != nil {
+			// previous empty
+			// log_module.AppLogger().Debug("previous empty")
+			scoreCache := judge_model.NewJudgeScoreCache(judge.UserAccount, judge.ProblemSlug)
+			if verdict == judge_model.JudgeVerdictAccepted {
+				extraPoint = 1
+				scoreCache.IsAccepted = true
+				scoreCache.SolveTime = judge.CreateAt
+			}
+			_, err := judge_model.CreateJudgeScoreCache(db, scoreCache)
+			if err != nil { // create fail, get data again and continue the update logic.
+				continue
+			}
+
+			// create success
+			rankCache.Points += int64(extraPoint)
+			rankCache.TotalSubmissions += 1
+			err = judge_model.UpdateJudgeRankCache(db, *rankCache)
+			if err != nil {
+				return err
+			}
+			return nil
+		} else {
+			break
+		}
+	}
+
+	// log_module.AppLogger().WithField("scoreCache", scoreCache).Debug("get scoreCache")
+
+	// previous no ac || current more early
+	// need to update
+	if !scoreCache.IsAccepted || judge.CreateAt.Before(*scoreCache.SolveTime) {
+		if !scoreCache.IsAccepted {
+			extraPoint = 1
+		}
+		preSubmissionCount := scoreCache.SubmissionCount
+		if verdict == judge_model.JudgeVerdictAccepted {
+			scoreCache.SubmissionCount, err = judge_model.GetBeforeSubmission(db, *judge) // rescan to count previous finished
+			if err != nil {
+				return err
+			}
+			scoreCache.IsAccepted = true
+			rankCache.Points = rankCache.Points + int64(extraPoint)
+			scoreCache.SolveTime = judge.CreateAt
+		} else {
+			scoreCache.SubmissionCount += 1
+		}
+		rankCache.TotalSubmissions += scoreCache.SubmissionCount - preSubmissionCount
+		// log_module.AppLogger().WithField("scoreCache", scoreCache).Debug("update scoreCache")
+
+		err = judge_model.UpdateJudgeScoreCache(db, *scoreCache)
+		if err != nil {
+			return err
+		}
+
+		err = judge_model.UpdateJudgeRankCache(db, *rankCache)
+		if err != nil {
+			return err
+		}
+	}
+	// if no early, no need update, just a query
+	return nil
+}