#2225

add admin reward operation record query api

models/reward_operate_record.go

@@ -111,129 +111,94 @@ const Semicolon = ";"
 type RewardOperateOrderBy string
 
 const (
-	RewardOrderByIDDesc RewardOperateOrderBy = "id desc"
+	RewardOrderByIDDesc RewardOperateOrderBy = "reward_operate_record.id desc"
 )
 
 type RewardRecordList []*RewardOperateRecord
 type RewardRecordShowList []*RewardOperateRecordShow
 
-func (l *RewardRecordList) ToShow() (RewardRecordShowList, error) {
-	actionMap, err := l.GetRewardRecordAction()
-	CloudbrainMap, err := l.GetRewardRecordCloudbrainTask()
-	if err != nil {
-		return nil, err
-	}
-	result := make([]*RewardOperateRecordShow, 0)
-	for _, v := range *l {
-		temp := v.ToShow()
-		switch v.SourceType {
-		case SourceTypeAccomplishTask.Name():
-			temp.Action = actionMap[v.SourceId].ToShow()
-		case SourceTypeRunCloudbrainTask.Name():
-			temp.Cloudbrain = CloudbrainMap[v.SourceId].ToShow()
-		}
-		result = append(result, &temp)
-	}
-
-	return result, nil
+func (l RewardRecordShowList) loadAttribute() {
+	l.loadAction()
+	l.loadCloudbrain()
 }
 
-func (l *RewardRecordList) GetRewardRecordAction() (map[string]*Action, error) {
-	if len(*l) == 0 {
-		return nil, nil
+func (l RewardRecordShowList) loadAction() error {
+	if len(l) == 0 {
+		return nil
 	}
 	actionIds := make([]int64, 0)
-	for _, r := range *l {
+	actionIdMap := make(map[int64]*RewardOperateRecordShow, 0)
+	for _, r := range l {
 		if r.SourceType != SourceTypeAccomplishTask.Name() {
 			continue
 		}
 		i, _ := strconv.ParseInt(r.SourceId, 10, 64)
 		actionIds = append(actionIds, i)
+		actionIdMap[i] = r
 	}
 	actions, err := GetActionByIds(actionIds)
 	if err != nil {
-		return nil, err
+		return err
 	}
-	result := make(map[string]*Action, 0)
 	for _, v := range actions {
-		result[fmt.Sprint(v.ID)] = v
-	}
-	return result, nil
-
-}
-
-func (l *RewardRecordList) GetRewardRecordAdminLog() (map[string]*RewardAdminLog, error) {
-	if len(*l) == 0 {
-		return nil, nil
-	}
-	logIds := make([]string, 0)
-	for _, r := range *l {
-		if r.SourceType != SourceTypeAdminOperate.Name() {
-			continue
-		}
-		logIds = append(logIds, r.SourceId)
-	}
-	logs, err := GetRewardAdminLogByLogIds(logIds)
-	if err != nil {
-		return nil, err
+		actionIdMap[v.ID].Action = v.ToShow()
 	}
-	result := make(map[string]*RewardAdminLog, 0)
-	for _, v := range logs {
-		result[fmt.Sprint(v.LogId)] = v
-	}
-	return result, nil
-
+	return nil
 }
 
-func (l *RewardRecordList) GetRewardRecordCloudbrainTask() (map[string]*Cloudbrain, error) {
-	if len(*l) == 0 {
-		return nil, nil
+func (l RewardRecordShowList) loadCloudbrain() error {
+	if len(l) == 0 {
+		return nil
 	}
 	cloudbrainIds := make([]int64, 0)
-	for _, r := range *l {
+	cloudbrainMap := make(map[int64]*RewardOperateRecordShow, 0)
+	for _, r := range l {
 		if r.SourceType != SourceTypeRunCloudbrainTask.Name() {
 			continue
 		}
 		i, _ := strconv.ParseInt(r.SourceId, 10, 64)
 		cloudbrainIds = append(cloudbrainIds, i)
+		cloudbrainMap[i] = r
 	}
 	cloudbrains, err := GetCloudbrainByIds(cloudbrainIds)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	var ids []int64
 	for _, task := range cloudbrains {
 		ids = append(ids, task.RepoID)
 	}
 	repositoryMap, err := GetRepositoriesMapByIDs(ids)
-	result := make(map[string]*Cloudbrain, 0)
-	if err == nil {
-		for _, v := range cloudbrains {
-			v.Repo = repositoryMap[v.RepoID]
-			result[fmt.Sprint(v.ID)] = v
-		}
+	if err != nil {
+		return err
+	}
+	for _, v := range cloudbrains {
+		v.Repo = repositoryMap[v.RepoID]
+		cloudbrainMap[v.ID].Cloudbrain = v.ToShow()
 	}
-	return result, nil
+
+	return nil
 
 }
 
 type RewardOperateRecord struct {
-	ID              int64  `xorm:"pk autoincr"`
-	SerialNo        string `xorm:"INDEX NOT NULL"`
-	UserId          int64  `xorm:"INDEX NOT NULL"`
-	Amount          int64  `xorm:"NOT NULL"`
-	LossAmount      int64
-	Tittle          string
-	RewardType      string `xorm:"NOT NULL"`
-	SourceType      string `xorm:"NOT NULL"`
-	SourceId        string `xorm:"INDEX NOT NULL"`
-	RequestId       string `xorm:"INDEX NOT NULL"`
-	OperateType     string `xorm:"NOT NULL"`
-	Status          string `xorm:"NOT NULL"`
-	Remark          string
-	CreatedUnix     timeutil.TimeStamp `xorm:"INDEX created"`
-	UpdatedUnix     timeutil.TimeStamp `xorm:"INDEX updated"`
-	LastOperateUnix timeutil.TimeStamp `xorm:"INDEX"`
+	ID               int64  `xorm:"pk autoincr"`
+	SerialNo         string `xorm:"INDEX NOT NULL"`
+	UserId           int64  `xorm:"INDEX NOT NULL"`
+	Amount           int64  `xorm:"NOT NULL"`
+	LossAmount       int64
+	Tittle           string
+	RewardType       string `xorm:"NOT NULL"`
+	SourceType       string `xorm:"NOT NULL"`
+	SourceId         string `xorm:"INDEX NOT NULL"`
+	SourceTemplateId string
+	RequestId        string `xorm:"INDEX NOT NULL"`
+	OperateType      string `xorm:"NOT NULL"`
+	Status           string `xorm:"NOT NULL"`
+	Remark           string
+	CreatedUnix      timeutil.TimeStamp `xorm:"INDEX created"`
+	UpdatedUnix      timeutil.TimeStamp `xorm:"INDEX updated"`
+	LastOperateUnix  timeutil.TimeStamp `xorm:"INDEX"`
 }
 
 type AdminRewardOperateReq struct {
@@ -244,31 +209,22 @@ type AdminRewardOperateReq struct {
 	RewardType   RewardType
 }
 
-func (r RewardOperateRecord) ToShow() RewardOperateRecordShow {
-	return RewardOperateRecordShow{
-		SerialNo:        r.SerialNo,
-		OperateType:     r.OperateType,
-		Amount:          r.Amount,
-		Remark:          r.Remark,
-		Status:          r.Status,
-		SourceType:      r.SourceType,
-		LastOperateDate: r.LastOperateUnix,
-		LossAmount:      r.LossAmount,
-	}
-}
-
 type RewardOperateRecordShow struct {
 	SerialNo        string
 	Status          string
 	OperateType     string
+	SourceId        string
 	Amount          int64
 	LossAmount      int64
+	BalanceAfter    int64
 	Remark          string
 	SourceType      string
+	UserName        string
 	LastOperateDate timeutil.TimeStamp
+	UnitPrice       int64
+	SuccessCount    int
 	Action          *ActionShow
 	Cloudbrain      *CloudbrainShow
-	AdminLog        *RewardAdminLog
 }
 
 func getPointOperateRecord(tl *RewardOperateRecord) (*RewardOperateRecord, error) {
@@ -326,6 +282,7 @@ func SumRewardAmountInTaskPeriod(rewardType string, sourceType string, userId in
 type RewardOperateContext struct {
 	SourceType        SourceType
 	SourceId          string
+	SourceTemplateId  string
 	Tittle            string
 	Remark            string
 	Reward            Reward
@@ -361,12 +318,18 @@ func AppendRemark(remark, appendStr string) string {
 type RewardRecordListOpts struct {
 	ListOptions
 	UserId      int64
+	UserName    string
 	OperateType RewardOperateType
 	RewardType  RewardType
+	SourceType  string
+	ActionType  int
+	SerialNo    string
 	OrderBy     RewardOperateOrderBy
+	IsAdmin     bool
+	Status      string
 }
 
-func GetRewardRecordList(opts RewardRecordListOpts) (RewardRecordList, int64, error) {
+func (opts *RewardRecordListOpts) toCond() builder.Cond {
 	if opts.Page <= 0 {
 		opts.Page = 1
 	}
@@ -375,25 +338,91 @@ func GetRewardRecordList(opts RewardRecordListOpts) (RewardRecordList, int64, er
 		opts.OrderBy = RewardOrderByIDDesc
 	}
 
-	r := make([]*RewardOperateRecord, 0)
 	cond := builder.NewCond()
 	if opts.UserId > 0 {
-		cond = cond.And(builder.Eq{"user_id": opts.UserId})
+		cond = cond.And(builder.Eq{"reward_operate_record.user_id": opts.UserId})
 	}
 	if opts.OperateType != OperateTypeNull {
-		cond = cond.And(builder.Eq{"operate_type": opts.OperateType.Name()})
+		cond = cond.And(builder.Eq{"reward_operate_record.operate_type": opts.OperateType.Name()})
+	}
+	if opts.SourceType != "" {
+		cond = cond.And(builder.Eq{"reward_operate_record.source_type": opts.SourceType})
+	}
+	if opts.SourceType == SourceTypeAccomplishTask.Name() {
+		if opts.ActionType > 0 {
+			cond = cond.And(builder.Eq{"reward_operate_record.source_template_id": fmt.Sprint(opts.ActionType)})
+		}
+	}
+	if opts.SerialNo != "" {
+		cond = cond.And(builder.Like{"reward_operate_record.serial_no", opts.SerialNo})
+	}
+	if opts.Status != "" {
+		cond = cond.And(builder.Like{"reward_operate_record.status", opts.Status})
+	}
+
+	cond = cond.And(builder.Eq{"reward_operate_record.reward_type": opts.RewardType.Name()})
+	cond = cond.And(builder.Gt{"reward_operate_record.amount": 0})
+	return cond
+}
+
+type TestTT struct {
+	SerialNo string
+	UserId   int64
+	Amount   int64
+	UserName string
+}
+
+func GetRewardRecordShowList(opts *RewardRecordListOpts) (RewardRecordShowList, int64, error) {
+	cond := opts.toCond()
+	count, err := x.Where(cond).Count(&RewardOperateRecord{})
+	if err != nil {
+		return nil, 0, err
 	}
-	cond = cond.And(builder.Eq{"reward_type": opts.RewardType.Name()})
-	cond = cond.And(builder.Gt{"amount": 0})
+	r := make([]*RewardOperateRecordShow, 0)
+	err = x.Table("reward_operate_record").Cols("reward_operate_record.source_id", "reward_operate_record.serial_no",
+		"reward_operate_record.status", "reward_operate_record.operate_type", "reward_operate_record.amount",
+		"reward_operate_record.loss_amount", "reward_operate_record.remark", "reward_operate_record.source_type",
+		"reward_operate_record.last_operate_unix as last_operate_date").
+		Where(cond).Limit(opts.PageSize, (opts.Page-1)*opts.PageSize).OrderBy(string(opts.OrderBy)).Find(&r)
 
+	if err != nil {
+		return nil, 0, err
+	}
+	RewardRecordShowList(r).loadAttribute()
+	return r, count, nil
+}
+
+func GetAdminRewardRecordShowList(opts *RewardRecordListOpts) (RewardRecordShowList, int64, error) {
+	cond := opts.toCond()
 	count, err := x.Where(cond).Count(&RewardOperateRecord{})
 	if err != nil {
 		return nil, 0, err
 	}
+	r := make([]*RewardOperateRecordShow, 0)
+	switch opts.OperateType {
+	case OperateTypeIncrease:
+		err = x.Table("reward_operate_record").Cols("reward_operate_record.source_id", "reward_operate_record.serial_no",
+			"reward_operate_record.status", "reward_operate_record.operate_type", "reward_operate_record.amount",
+			"reward_operate_record.loss_amount", "reward_operate_record.remark", "reward_operate_record.source_type",
+			"reward_operate_record.last_operate_unix as last_operate_date", "public.user.name as user_name",
+			"point_account_log.balance_after").
+			Join("LEFT", "public.user", "reward_operate_record.user_id = public.user.id").
+			Join("LEFT", "point_account_log", " reward_operate_record.serial_no = point_account_log.source_id").
+			Where(cond).Limit(opts.PageSize, (opts.Page-1)*opts.PageSize).OrderBy(string(opts.OrderBy)).Find(&r)
+	case OperateTypeDecrease:
+		err = x.Table("reward_operate_record").Cols("reward_operate_record.source_id", "reward_operate_record.serial_no",
+			"reward_operate_record.status", "reward_operate_record.operate_type", "reward_operate_record.amount",
+			"reward_operate_record.loss_amount", "reward_operate_record.remark", "reward_operate_record.source_type",
+			"reward_operate_record.last_operate_unix as last_operate_date", "public.user.name as user_name",
+			"reward_periodic_task.amount as unit_price", "reward_periodic_task.success_count").
+			Join("LEFT", "public.user", "reward_operate_record.user_id = public.user.id").
+			Join("LEFT", "reward_periodic_task", "reward_operate_record.serial_no = reward_periodic_task.operate_serial_no").
+			Where(cond).Limit(opts.PageSize, (opts.Page-1)*opts.PageSize).OrderBy(string(opts.OrderBy)).Find(&r)
+	}
 
-	err = x.Where(cond).Limit(opts.PageSize, (opts.Page-1)*opts.PageSize).OrderBy(string(opts.OrderBy)).Find(&r)
 	if err != nil {
 		return nil, 0, err
 	}
+	RewardRecordShowList(r).loadAttribute()
 	return r, count, nil
 }

routers/reward/point/point.go

@@ -7,6 +7,7 @@ import (
 	"code.gitea.io/gitea/routers/response"
 	"code.gitea.io/gitea/services/reward"
 	"code.gitea.io/gitea/services/reward/point/account"
+	"errors"
 	"net/http"
 )
 
@@ -48,12 +49,14 @@ func GetPointRecordList(ctx *context.Context) {
 		return
 	}
 
-	r, err := reward.GetRewardRecordList(models.RewardRecordListOpts{
+	r, err := reward.GetRewardRecordList(&models.RewardRecordListOpts{
 		ListOptions: models.ListOptions{PageSize: 10, Page: page},
 		UserId:      ctx.User.ID,
 		OperateType: t,
 		RewardType:  models.RewardTypePoint,
 		OrderBy:     orderBy,
+		IsAdmin:     false,
+		UserName:    ctx.User.Name,
 	})
 	if err != nil {
 		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
@@ -85,3 +88,66 @@ func GetPointPage(ctx *context.Context) {
 func GetRulePage(ctx *context.Context) {
 	ctx.HTML(200, tplPointRule)
 }
+
+func GetAdminRewardList(ctx *context.Context) {
+	opts, err := buildAdminRewardRecordListOpts(ctx)
+	if err != nil {
+		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
+		return
+	}
+
+	username := ctx.Query("userName")
+	if username != "" {
+		user, err := models.GetUserByName(username)
+		if err != nil {
+			if models.IsErrUserNotExist(err) {
+				ctx.JSON(http.StatusOK, response.ServerError("user not exist"))
+			} else {
+				ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
+			}
+			return
+		}
+		opts.UserId = user.ID
+		opts.UserName = user.Name
+	}
+
+	r, err := reward.GetRewardRecordList(opts)
+	if err != nil {
+		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
+		return
+	}
+
+	ctx.JSON(http.StatusOK, response.SuccessWithData(r))
+}
+
+func buildAdminRewardRecordListOpts(ctx *context.Context) (*models.RewardRecordListOpts, error) {
+	operateType := ctx.Query("operate")
+	sourceType := ctx.Query("source")
+	actionType := ctx.QueryInt("action")
+	serialNo := ctx.Query("serialNo")
+	status := ctx.Query("status")
+
+	page := ctx.QueryInt("page")
+	var orderBy models.RewardOperateOrderBy
+	switch ctx.Query("sort") {
+	default:
+		orderBy = models.RewardOrderByIDDesc
+	}
+	t := models.GetRewardOperateTypeInstance(operateType)
+	if t == "" {
+		return nil, errors.New("param error")
+	}
+	opts := &models.RewardRecordListOpts{
+		ListOptions: models.ListOptions{PageSize: 10, Page: page},
+		UserId:      ctx.User.ID,
+		OperateType: t,
+		RewardType:  models.RewardTypePoint,
+		OrderBy:     orderBy,
+		SourceType:  sourceType,
+		ActionType:  actionType,
+		SerialNo:    serialNo,
+		IsAdmin:     true,
+		Status:      status,
+	}
+	return opts, nil
+}

routers/routes/routes.go

@@ -610,6 +610,7 @@ func RegisterRoutes(m *macaron.Macaron) {
 			m.Post("/limiter/delete", point.DeletePointLimitConfig)
 			m.Get("/account/search", point.SearchPointAccount)
 			m.Post("/account/operate", binding.Bind(models.AdminRewardOperateReq{}), point.OperatePointAccountBalance)
+			m.Get("/list", point.GetAdminRewardList)
 		})
 
 		m.Group("/task/config", func() {

services/reward/operator.go

@@ -122,18 +122,19 @@ func initRewardOperateRecord(ctx *models.RewardOperateContext) (string, error) {
 		return "", err
 	}
 	record := &models.RewardOperateRecord{
-		UserId:      ctx.TargetUserId,
-		Amount:      ctx.Reward.Amount,
-		LossAmount:  ctx.LossAmount,
-		RewardType:  ctx.Reward.Type.Name(),
-		SourceType:  ctx.SourceType.Name(),
-		SourceId:    ctx.SourceId,
-		RequestId:   ctx.RequestId,
-		OperateType: ctx.OperateType.Name(),
-		Status:      models.OperateStatusOperating,
-		Remark:      ctx.Remark,
-		Tittle:      ctx.Tittle,
-		SerialNo:    sn,
+		UserId:           ctx.TargetUserId,
+		Amount:           ctx.Reward.Amount,
+		LossAmount:       ctx.LossAmount,
+		RewardType:       ctx.Reward.Type.Name(),
+		SourceType:       ctx.SourceType.Name(),
+		SourceId:         ctx.SourceId,
+		SourceTemplateId: ctx.SourceTemplateId,
+		RequestId:        ctx.RequestId,
+		OperateType:      ctx.OperateType.Name(),
+		Status:           models.OperateStatusOperating,
+		Remark:           ctx.Remark,
+		Tittle:           ctx.Tittle,
+		SerialNo:         sn,
 	}
 	_, err = models.InsertRewardOperateRecord(record)
 	if err != nil {

services/reward/record.go

@@ -12,8 +12,15 @@ type RecordResponse struct {
 	Page     int
 }
 
-func GetRewardRecordList(opts models.RewardRecordListOpts) (*RecordResponse, error) {
-	l, n, err := models.GetRewardRecordList(opts)
+func GetRewardRecordList(opts *models.RewardRecordListOpts) (*RecordResponse, error) {
+	var l models.RewardRecordShowList
+	var n int64
+	var err error
+	if opts.IsAdmin {
+		l, n, err = models.GetAdminRewardRecordShowList(opts)
+	} else {
+		l, n, err = models.GetRewardRecordShowList(opts)
+	}
 	if err != nil {
 		log.Error("GetRewardRecordList error. %v", err)
 
@@ -22,11 +29,19 @@ func GetRewardRecordList(opts models.RewardRecordListOpts) (*RecordResponse, err
 	if len(l) == 0 {
 		return &RecordResponse{Records: make([]*models.RewardOperateRecordShow, 0), Total: n, Page: opts.Page, PageSize: opts.PageSize}, nil
 	}
-	result, err := l.ToShow()
-	if err != nil {
-		log.Error("GetRewardRecordList ToShow error. %v", err)
-		return nil, err
-	}
+	return &RecordResponse{Records: l, Total: n, Page: opts.Page, PageSize: opts.PageSize}, nil
+}
 
-	return &RecordResponse{Records: result, Total: n, Page: opts.Page, PageSize: opts.PageSize}, nil
+func handleRecordResponse(opts *models.RewardRecordListOpts, list models.RewardRecordShowList) {
+	if opts.IsAdmin {
+		for _, v := range list {
+			v.UserName = opts.UserName
+		}
+	} else {
+		for _, v := range list {
+			if v.Cloudbrain != nil {
+				v.Cloudbrain.AiCenter = ""
+			}
+		}
+	}
 }

services/task/task.go

@@ -81,9 +81,10 @@ func accomplish(action models.Action) error {
 
 	//reward
 	reward.Operate(&models.RewardOperateContext{
-		SourceType: models.SourceTypeAccomplishTask,
-		SourceId:   fmt.Sprint(action.ID),
-		Tittle:     config.Tittle,
+		SourceType:       models.SourceTypeAccomplishTask,
+		SourceId:         fmt.Sprint(action.ID),
+		SourceTemplateId: fmt.Sprint(action.OpType),
+		Tittle:           config.Tittle,
 		Reward: models.Reward{
 			Amount: config.AwardAmount,
 			Type:   models.GetRewardTypeInstance(config.AwardType),