aiforge/models/resource_specification.go

package models

import (
	"code.gitea.io/gitea/modules/timeutil"
	"xorm.io/builder"
)

const (
	SpecNotVerified int = iota + 1
	SpecEffective
	SpecNotEffective
)

type ResourceSpecification struct {
	ID              int64  `xorm:"pk autoincr"`
	QueueId         int64  `xorm:"INDEX"`
	SourceSpecId    string `xorm:"INDEX"`
	AccCardsNum     int
	CpuNum          int
	MemMiB          int
	ShareMemMiB     int
	UnitPrice       int
	Status          int
	IsAutomaticSync bool
	CreatedTime     timeutil.TimeStamp `xorm:"created"`
	CreatedBy       int64
	UpdatedTime     timeutil.TimeStamp `xorm:"updated"`
	UpdatedBy       int64
}

func (r ResourceSpecification) ConvertToRes() *ResourceSpecificationRes {
	return &ResourceSpecificationRes{
		ID:           r.ID,
		SourceSpecId: r.SourceSpecId,
		AccCardsNum:  r.AccCardsNum,
		CpuNum:       r.CpuNum,
		MemMiB:       r.MemMiB,
		ShareMemMiB:  r.ShareMemMiB,
		UnitPrice:    r.UnitPrice,
		Status:       r.Status,
	}
}

type ResourceSpecificationReq struct {
	QueueId         int64 `binding:"Required"`
	AccCardsNum     int
	CpuNum          int
	MemGiB          int
	ShareMemGiB     int
	UnitPrice       int
	Status          int
	IsAutomaticSync bool
	CreatorId       int64
}

func (r ResourceSpecificationReq) ToDTO() ResourceSpecification {
	return ResourceSpecification{
		QueueId:         r.QueueId,
		AccCardsNum:     r.AccCardsNum,
		CpuNum:          r.CpuNum,
		MemMiB:          r.MemGiB * 1024,
		ShareMemMiB:     r.ShareMemGiB * 1024,
		UnitPrice:       r.UnitPrice,
		Status:          r.Status,
		IsAutomaticSync: r.IsAutomaticSync,
		CreatedBy:       r.CreatorId,
		UpdatedBy:       r.CreatorId,
	}
}

type SearchResourceSpecificationOptions struct {
	ListOptions
	QueueId int64
	Status  int
}

type ResourceSpecAndQueueListRes struct {
	TotalSize int64
	List      []*ResourceSpecAndQueueRes
}

func NewResourceSpecAndQueueListRes(totalSize int64, list []ResourceSpecAndQueue) *ResourceSpecAndQueueListRes {
	resList := make([]*ResourceSpecAndQueueRes, len(list))
	for i, v := range list {
		resList[i] = v.ConvertToRes()
	}
	return &ResourceSpecAndQueueListRes{
		TotalSize: totalSize,
		List:      resList,
	}
}

type ResourceSpecificationRes struct {
	ID           int64
	SourceSpecId string
	AccCardsNum  int
	CpuNum       int
	MemMiB       int
	ShareMemMiB  int
	UnitPrice    int
	Status       int
}

type ResourceSpecAndQueueRes struct {
	Spec  *ResourceSpecificationRes
	Queue *ResourceQueueRes
}

type ResourceSpecAndQueue struct {
	ResourceSpecification `xorm:"extends"`
	ResourceQueue         `xorm:"extends"`
}

func (*ResourceSpecAndQueue) TableName() string {
	return "resource_specification"
}

func (r ResourceSpecAndQueue) ConvertToRes() *ResourceSpecAndQueueRes {
	return &ResourceSpecAndQueueRes{
		Spec:  r.ResourceSpecification.ConvertToRes(),
		Queue: r.ResourceQueue.ConvertToRes(),
	}
}

func InsertResourceSpecification(queue ResourceSpecification) (int64, error) {
	return x.Insert(&queue)
}

func UpdateResourceSpecificationById(queueId int64, queue ResourceSpecification) (int64, error) {
	return x.ID(queueId).Update(&queue)
}

func SearchResourceSpecification(opts SearchResourceSpecificationOptions) (int64, []ResourceSpecAndQueue, error) {
	var cond = builder.NewCond()
	if opts.Page <= 0 {
		opts.Page = 1
	}
	if opts.QueueId > 0 {
		cond = cond.And(builder.Eq{"resource_specification.queue_id": opts.QueueId})
	}
	if opts.Status > 0 {
		cond = cond.And(builder.Eq{"resource_specification.status": opts.Status})
	}
	n, err := x.Where(cond).Count(&ResourceSpecAndQueue{})
	if err != nil {
		return 0, nil, err
	}

	r := make([]ResourceSpecAndQueue, 0)
	err = x.Where(cond).
		Join("LEFT", "resource_queue", "resource_queue.ID = resource_specification.queue_id").
		Desc("resource_specification.id").
		Limit(opts.PageSize, (opts.Page-1)*opts.PageSize).
		Find(&r)
	if err != nil {
		return 0, nil, err
	}
	return n, r, nil
}