aiforge/routers/admin/resources.go

package admin

import (
	"code.gitea.io/gitea/models"
	"code.gitea.io/gitea/modules/base"
	"code.gitea.io/gitea/modules/context"
	"code.gitea.io/gitea/modules/log"
	"code.gitea.io/gitea/routers/response"
	"code.gitea.io/gitea/services/cloudbrain/resource"
	"net/http"
	"strconv"
	"strings"
)

const (
	tplResourceQueue         base.TplName = "admin/resources/queue"
	tplResourceSpecification base.TplName = "admin/resources/specification"
	tplResourceScene         base.TplName = "admin/resources/scene"
)

func GetQueuePage(ctx *context.Context) {
	ctx.Data["PageIsAdmin"] = true
	ctx.Data["PageIsAdminResources"] = true
	ctx.Data["PageIsAdminResourcesQueue"] = true
	ctx.HTML(200, tplResourceQueue)
}

func GetSpecificationPage(ctx *context.Context) {
	ctx.Data["PageIsAdmin"] = true
	ctx.Data["PageIsAdminResources"] = true
	ctx.Data["PageIsAdminResourcesSpecification"] = true
	ctx.HTML(200, tplResourceSpecification)
}

func GetScenePage(ctx *context.Context) {
	ctx.Data["PageIsAdmin"] = true
	ctx.Data["PageIsAdminResources"] = true
	ctx.Data["PageIsAdminResourcesScene"] = true
	ctx.HTML(200, tplResourceScene)
}

func GetResourceQueueList(ctx *context.Context) {
	page := ctx.QueryInt("page")
	cluster := ctx.Query("cluster")
	aiCenterCode := ctx.Query("center")
	computeResource := ctx.Query("resource")
	accCardType := ctx.Query("card")
	list, err := resource.GetResourceQueueList(models.SearchResourceQueueOptions{
		ListOptions:     models.ListOptions{Page: page, PageSize: 10},
		Cluster:         cluster,
		AiCenterCode:    aiCenterCode,
		ComputeResource: computeResource,
		AccCardType:     accCardType,
	})
	if err != nil {
		log.Error("GetResourceQueueList error.%v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.SuccessWithData(list))
}

func GetResourceQueueCodes(ctx *context.Context) {
	cluster := ctx.Query("cluster")
	list, err := resource.GetResourceQueueCodes(models.GetQueueCodesOptions{Cluster: cluster})
	if err != nil {
		log.Error("GetResourceQueueCodes error.%v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.SuccessWithData(list))
}

func GetResourceAiCenters(ctx *context.Context) {
	list, err := resource.GetResourceAiCenters()
	if err != nil {
		log.Error("GetResourceAiCenters error.%v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.SuccessWithData(list))
}

func AddResourceQueue(ctx *context.Context, req models.ResourceQueueReq) {
	req.IsAutomaticSync = false
	req.CreatorId = ctx.User.ID
	err := resource.AddResourceQueue(req)
	if err != nil {
		log.Error("AddResourceQueue error. %v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.Success())
}

func UpdateResourceQueue(ctx *context.Context, req models.ResourceQueueReq) {
	queueId := ctx.ParamsInt64(":id")
	//only CardsTotalNum permitted to change
	err := resource.UpdateResourceQueue(queueId, req)
	if err != nil {
		log.Error("UpdateResourceQueue error. %v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.Success())
}

func SyncGrampusQueue(ctx *context.Context) {
	err := resource.SyncGrampusQueue(ctx.User.ID)
	if err != nil {
		log.Error("AddResourceQueue error. %v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.Success())
}

func GetResourceSpecificationList(ctx *context.Context) {
	page := ctx.QueryInt("page")
	queue := ctx.QueryInt64("queue")
	status := ctx.QueryInt("status")
	cluster := ctx.Query("cluster")
	available := ctx.QueryInt("available")
	list, err := resource.GetResourceSpecificationList(models.SearchResourceSpecificationOptions{
		ListOptions:   models.ListOptions{Page: page, PageSize: 10},
		QueueId:       queue,
		Status:        status,
		Cluster:       cluster,
		AvailableCode: available,
	})
	if err != nil {
		log.Error("GetResourceSpecificationList error.%v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.SuccessWithData(list))
}

func GetResourceSpecificationScenes(ctx *context.Context) {
	specId := ctx.ParamsInt64(":id")
	list, err := resource.GetResourceSpecificationScenes(specId)
	if err != nil {
		log.Error("GetResourceSpecificationScenes error.%v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	r := make(map[string]interface{})
	r["List"] = list
	ctx.JSON(http.StatusOK, response.SuccessWithData(r))
}

func AddResourceSpecification(ctx *context.Context, req models.ResourceSpecificationReq) {
	req.IsAutomaticSync = false
	req.CreatorId = ctx.User.ID
	err := resource.AddResourceSpecification(ctx.User.ID, req)
	if err != nil {
		log.Error("AddResourceQueue error. %v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.Success())
}

func UpdateResourceSpecification(ctx *context.Context, req models.ResourceSpecificationReq) {
	id := ctx.ParamsInt64(":id")
	action := ctx.Query("action")

	var err *response.BizError
	switch action {
	case "edit":
		if req.UnitPrice < 0 {
			ctx.JSON(http.StatusOK, response.ServerError("param error"))
			return
		}
		//only UnitPrice and  permitted to change
		err = resource.UpdateSpecUnitPrice(ctx.User.ID, id, req.UnitPrice)
	case "on-shelf":
		err = resource.ResourceSpecOnShelf(ctx.User.ID, id, req.UnitPrice)
	case "off-shelf":
		err = resource.ResourceSpecOffShelf(ctx.User.ID, id)
	}

	if err != nil {
		log.Error("UpdateResourceSpecification error. %v", err)
		ctx.JSON(http.StatusOK, response.ResponseError(err))
		return
	}
	ctx.JSON(http.StatusOK, response.Success())
}

func SyncGrampusSpecs(ctx *context.Context) {
	err := resource.SyncGrampusSpecs(ctx.User.ID)
	if err != nil {
		log.Error("AddResourceQueue error. %v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.Success())
}

func GetResourceSceneList(ctx *context.Context) {
	page := ctx.QueryInt("page")
	jobType := ctx.Query("jobType")
	aiCenterCode := ctx.Query("center")
	queueId := ctx.QueryInt64("queue")
	isExclusive := ctx.QueryInt("IsExclusive")
	list, err := resource.GetResourceSceneList(models.SearchResourceSceneOptions{
		ListOptions:  models.ListOptions{Page: page, PageSize: 10},
		JobType:      jobType,
		IsExclusive:  isExclusive,
		AiCenterCode: aiCenterCode,
		QueueId:      queueId,
	})
	if err != nil {
		log.Error("GetResourceSceneList error.%v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.SuccessWithData(list))
}

func AddResourceScene(ctx *context.Context, req models.ResourceSceneReq) {
	req.CreatorId = ctx.User.ID
	req.ExclusiveOrg = strings.ReplaceAll(req.ExclusiveOrg, " ", "")
	err := resource.AddResourceScene(req)
	if err != nil {
		log.Error("AddResourceScene error. %v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.Success())
}

func UpdateResourceScene(ctx *context.Context, req models.ResourceSceneReq) {
	id := ctx.ParamsInt64(":id")
	action := ctx.Query("action")

	req.ID = id
	var err error
	switch action {
	case "edit":
		req.ExclusiveOrg = strings.ReplaceAll(req.ExclusiveOrg, " ", "")
		err = resource.UpdateResourceScene(req)
	case "delete":
		err = resource.DeleteResourceScene(id)
	}

	if err != nil {
		log.Error("UpdateResourceScene error. %v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	ctx.JSON(http.StatusOK, response.Success())
}

func RefreshHistorySpec(ctx *context.Context) {
	scope := ctx.Query("scope")
	list := ctx.Query("list")

	var scopeAll = false
	if scope == "all" {
		scopeAll = true
	}
	var ids = make([]int64, 0)
	if list != "" {
		strs := strings.Split(list, "|")
		for _, s := range strs {
			i, err := strconv.ParseInt(s, 10, 64)
			if err != nil {
				ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
				return
			}
			ids = append(ids, i)
		}

	}

	total, success, err := resource.RefreshHistorySpec(scopeAll, ids)
	if err != nil {
		log.Error("RefreshHistorySpec error. %v", err)
		ctx.JSON(http.StatusOK, response.ServerError(err.Error()))
		return
	}
	r := make(map[string]interface{}, 0)
	r["success"] = success
	r["total"] = total
	ctx.JSON(http.StatusOK, response.SuccessWithData(r))
}