aiforge/routers/dataset/dataset.go

package dataset

import (
	"code.gitea.io/gitea/models"
	"code.gitea.io/gitea/modules/auth"
	"code.gitea.io/gitea/modules/base"
	"code.gitea.io/gitea/modules/context"
	"code.gitea.io/gitea/modules/log"
	"code.gitea.io/gitea/modules/setting"
	"code.gitea.io/gitea/routers/repo"
	"github.com/unknwon/com"
)

const (
	tplDataSet base.TplName = "datasets/index"
	tplShow    base.TplName = "datasets/show"
	tplCreate  base.TplName = "datasets/create"
)

type ListOptions struct {
	PageSize int
	Page     int // start from 1
}

func MyList(ctx *context.Context) {

	var (
		datasets []*models.Dataset
		count    int64
		err      error
		orderBy  models.SearchOrderBy
	)

	ctxUser := ctx.User
	page := ctx.QueryInt("page")
	if page <= 0 {
		page = 1
	}
	switch ctx.Query("sort") {
	case "newest":
		orderBy = models.SearchOrderByNewest
	case "oldest":
		orderBy = models.SearchOrderByOldest
	case "recentupdate":
		orderBy = models.SearchOrderByRecentUpdated
	case "leastupdate":
		orderBy = models.SearchOrderByLeastUpdated
	case "reversealphabetically":
		orderBy = models.SearchOrderByAlphabeticallyReverse
	case "alphabetically":
		orderBy = models.SearchOrderByAlphabetically
	case "reversesize":
		orderBy = models.SearchOrderBySizeReverse
	case "size":
		orderBy = models.SearchOrderBySize
	case "moststars":
		orderBy = models.SearchOrderByStarsReverse
	case "feweststars":
		orderBy = models.SearchOrderByStars
	case "mostforks":
		orderBy = models.SearchOrderByForksReverse
	case "fewestforks":
		orderBy = models.SearchOrderByForks
	default:
		ctx.Data["SortType"] = "recentupdate"
		orderBy = models.SearchOrderByRecentUpdated
	}
	datasetSearchOptions := &models.SearchDatasetOptions{
		Keyword:       ctx.QueryTrim("keyword"),
		OwnerID:       ctxUser.ID,
		IsPublic:      false,
		SearchOrderBy: orderBy,
		ListOptions: models.ListOptions{
			Page:     page,
			PageSize: setting.UI.ExplorePagingNum,
		},
	}

	if len(datasetSearchOptions.SearchOrderBy) == 0 {
		datasetSearchOptions.SearchOrderBy = models.SearchOrderByAlphabetically
	}

	datasets, count, err = models.SearchDataset(datasetSearchOptions)
	if err != nil {
		ctx.ServerError("SearchDatasets", err)
		return
	}

	// pager := context.NewPagination(int(count), opts.PageSize, page, 5)
	// pager.SetDefaultParams(ctx)
	// pager.AddParam(ctx, "topic", "TopicOnly")
	// ctx.Data["Page"] = pager

	ctx.Data["datasets"] = datasets
	ctx.Data["datasetsCount"] = count
	log.Debug("[dataset] mylist...\n")
	ctx.HTML(200, tplDataSet)
}

func Create(ctx *context.Context) {
	log.Debug("[dataset] Create...\n")
	ctx.HTML(200, tplCreate)
}

// func handleCreateError(ctx *context.Context, owner *models.User, err error, name string, tpl base.TplName, form interface{}) {
// 	switch {
// 	case models.IsErrReachLimitOfRepo(err):
// 		ctx.RenderWithErr(ctx.Tr("repo.form.reach_limit_of_creation", owner.MaxCreationLimit()), tpl, form)
// 	case models.IsErrRepoAlreadyExist(err):
// 		ctx.Data["Err_RepoName"] = true
// 		ctx.RenderWithErr(ctx.Tr("form.repo_name_been_taken"), tpl, form)
// 	case models.IsErrNameReserved(err):
// 		ctx.Data["Err_RepoName"] = true
// 		ctx.RenderWithErr(ctx.Tr("repo.form.name_reserved", err.(models.ErrNameReserved).Name), tpl, form)
// 	case models.IsErrNamePatternNotAllowed(err):
// 		ctx.Data["Err_RepoName"] = true
// 		ctx.RenderWithErr(ctx.Tr("repo.form.name_pattern_not_allowed", err.(models.ErrNamePatternNotAllowed).Pattern), tpl, form)
// 	default:
// 		ctx.ServerError(name, err)
// 	}
// }

func CreatePost(ctx *context.Context, form auth.CreateDatasetForm) {
	ctx.Data["Title"] = ctx.Tr("new_dataset")

	ctxUser := ctx.User

	if ctx.HasError() {
		ctx.HTML(200, tplCreate)
		return
	}

	status := 2
	if form.Status {
		status = 1
	}

	var err error
	opts := models.Dataset{
		Title:       form.Title,
		Category:    form.Category,
		Description: form.Description,
		License:     form.License,
		Task:        form.Task,
		ReleaseID:   form.ReleaseID,
		UserID:      ctxUser.ID,
		Status:      int32(status),
	}
	// if !opts.IsValid() {
	// 	ctx.RenderWithErr(ctx.Tr("repo.template.one_item"), tplCreate, form)
	// 	return
	// }

	if err = models.CreateDataset(&opts); err != nil {
		log.Error("%v", err)
	}

	var attachmentUUIDs []string
	if setting.Attachment.Enabled {
		attachmentUUIDs = form.Files
	}

	log.Error("%v", attachmentUUIDs)

	if err = models.AddDatasetAttachments(opts.ID, attachmentUUIDs); err != nil {
		log.Error("%v", err)
	}

	if err == nil {
		log.Trace("Dataset created [%d]: %s/%s", opts.ID, ctxUser.Name, opts.Title)
		ctx.Redirect(setting.AppSubURL + "/datasets/" + com.ToStr(opts.ID))
		return
	}

	// handleCreateError(ctx, ctxUser, err, "CreatePost", tplCreate, &form)
}

func Show(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("dataset.show_dataset")

	dataset, err := models.GetDatasetByID(ctx.ParamsInt64((":id")))
	if err != nil {
		ctx.ServerError("GetDataset", err)
		return
	}

	err = models.GeDatasetAttachments(dataset)
	if err != nil {
		ctx.ServerError("GetDatasetAttachments", err)
		return
	}

	ctx.Data["dataset"] = dataset

	ctx.HTML(200, tplShow)
}

// EditRelease render release edit page
func EditDataset(ctx *context.Context) {
	ctx.Data["Title"] = ctx.Tr("dataset.edit_dataset")
	ctx.Data["PageIsEditDataset"] = true
	repo.RenderAttachmentSettings(ctx)
	rel, err := models.GetDatasetByID(ctx.ParamsInt64(":id"))
	if err != nil {
		ctx.ServerError("GetDataset", err)
		return
	}
	ctx.Data["ID"] = rel.ID
	ctx.Data["title"] = rel.Title
	ctx.Data["description"] = rel.Description
	ctx.Data["category"] = rel.Category
	ctx.Data["task"] = rel.Task
	ctx.Data["license"] = rel.License

	ctx.HTML(200, tplCreate)
}

func EditDatasetPost(ctx *context.Context, form auth.EditDatasetForm) {
	ctx.Data["Title"] = ctx.Tr("dataset.edit_dataset")
	ctx.Data["PageIsEditDataset"] = true

	rel, err := models.GetDatasetByID(ctx.ParamsInt64(":id"))
	if err != nil {
		ctx.ServerError("GetDataset", err)
		return
	}
	ctx.Data["ID"] = rel.ID
	ctx.Data["title"] = rel.Title
	ctx.Data["description"] = rel.Description
	ctx.Data["category"] = rel.Category
	ctx.Data["task"] = rel.Task
	ctx.Data["license"] = rel.License
	ctx.Data["status"] = rel.Status

	if ctx.HasError() {
		ctx.HTML(200, tplCreate)
		return
	}

	var attachmentUUIDs []string
	if setting.Attachment.Enabled {
		attachmentUUIDs = form.Files
	}

	status := 2
	if form.Status {
		status = 1
	}

	rel.Title = form.Title
	rel.Status = int32(status)
	rel.Description = form.Description
	rel.Category = form.Category
	rel.Task = form.Task
	rel.License = form.License
	if err = models.UpdateDataset(models.DefaultDBContext(), rel); err != nil {
		log.Error("%v", err)
	}

	if err = models.AddDatasetAttachments(rel.ID, attachmentUUIDs); err != nil {
		log.Error("%v", err)
	}
	log.Trace("Dataset updated: %d", rel.ID)

	ctx.Redirect(setting.AppSubURL + "/datasets/" + com.ToStr(rel.ID))
}

func Delete(ctx *context.Context) {
	log.Debug("[dataset] Delete...\n")
}