aiforge/services/task/task_config.go

package task

import (
	"code.gitea.io/gitea/models"
	"code.gitea.io/gitea/modules/log"
	"code.gitea.io/gitea/modules/redis/redis_client"
	"code.gitea.io/gitea/modules/redis/redis_key"
	"code.gitea.io/gitea/services/reward/limiter"
	"encoding/json"
	"time"
)

//GetTaskConfig get task config from redis cache first
// if not exist in redis, find in db and refresh the redis key
func GetTaskConfig(taskType string) (*models.TaskConfig, error) {
	list, err := GetTaskConfigList()
	if err != nil {
		return nil, err
	}
	for _, v := range list {
		if v.TaskCode == taskType {
			return v, nil
		}
	}
	return nil, nil
}

func GetTaskConfigList() ([]*models.TaskConfig, error) {
	redisKey := redis_key.TaskConfigList()
	configStr, _ := redis_client.Get(redisKey)
	if configStr != "" {
		if configStr == redis_key.EMPTY_REDIS_VAL {
			return nil, nil
		}
		config := make([]*models.TaskConfig, 0)
		json.Unmarshal([]byte(configStr), &config)
		return config, nil
	}
	config, err := models.GetTaskConfigList()
	if err != nil {
		if models.IsErrRecordNotExist(err) {
			redis_client.Setex(redisKey, redis_key.EMPTY_REDIS_VAL, 5*time.Second)
			return nil, nil
		}
		return nil, err
	}
	jsonStr, _ := json.Marshal(config)
	redis_client.Setex(redisKey, string(jsonStr), 30*24*time.Hour)
	return config, nil
}

func GetTaskConfigWithLimitList() ([]*models.TaskConfigWithLimit, error) {
	list, err := GetTaskConfigList()
	if err != nil {
		return nil, err
	}
	if len(list) == 0 {
		return nil, nil
	}
	r := make([]*models.TaskConfigWithLimit, 0)
	l, err := limiter.GetLimitersByLimitType(models.LimitTypeTask)
	if err != nil {
		return nil, err
	}
	for i := 0; i < len(list); i++ {
		li := list[i]
		t := &models.TaskConfigWithLimit{
			TaskCode:    li.TaskCode,
			Tittle:      li.Tittle,
			AwardType:   li.AwardType,
			AwardAmount: li.AwardAmount,
			Creator:     li.CreatorName,
			CreatedUnix: li.CreatedUnix,
		}
		lv := make([]models.LimitConfigVO, 0)
		for j := 0; j < len(l); j++ {
			lj := l[j]
			if lj.LimitCode == li.TaskCode {
				lv = append(lv, models.LimitConfigVO{
					Tittle:      lj.Tittle,
					RefreshRate: lj.RefreshRate,
					Scope:       lj.Scope,
					LimitNum:    lj.LimitNum,
					Creator:     lj.CreatorName,
					CreatedUnix: lj.CreatedUnix,
				})
			}
		}
		t.Limiters = lv
		r = append(r, t)
	}
	return r, nil
}

func AddTaskConfig(config models.TaskConfigWithLimit, doer *models.User) error {
	err := models.AddTaskConfig(config, doer)
	if err != nil {
		log.Error("add task config error,config:%v  err:%v", config, err)
		return err
	}
	redis_client.Del(redis_key.LimitConfig(models.LimitTypeTask))
	redis_client.Del(redis_key.TaskConfigList())
	return nil
}