AutomatedTesting/usecases_server/controlles/at/showcase/showcase_.go

package showcase

import (
	"encoding/json"
	"fmt"
	"automatedtesting/usecases_server/models"
	"automatedtesting/usecases_server/utils"
	"automatedtesting/usecases_server/utils/cyllib/log"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

func (s *CaseController) get_input(input []utils.Inputdata) (module, index string) {
	for _, d := range input {
		switch d.Name {
		case "module":
			module = d.Input
		case "index":
			index = d.Input
		}
	}
	return
}
func (s *CaseController) GetCaseData(public utils.PublicData, c *gin.Context) (*[]CaseController, int64) {
	casec := []CaseController{}
	var total int64
	module, index := s.get_input(public.Input)
	che := public.Checked
	var pubgorm *gorm.DB
	pubgorm = models.GetDb().Table("cases").Where("gid = ? and child_module like ? and indexes like ?", public.Id, utils.LikeJoin(module), "%%"+index+"%%")
	if che.Succ == "" && che.Fail == "" {

	} else if che.Succ == "checked" && che.Fail == "checked" {
		pubgorm = pubgorm.Where("result <> ?", "")
	} else if che.Succ == "checked" && che.Fail == "" {
		pubgorm = pubgorm.Where("result = ?", "T")
	} else if che.Succ == "" && che.Fail == "checked" {
		pubgorm = pubgorm.Where("result = ?", "F")
	}

	if err := pubgorm.Count(&total).Error; err != nil {
		log.WriteErr(err)
	}
	if err := pubgorm.Order("id").Limit(public.Limit).Offset(public.Offset).Find(&casec).Error; err != nil {
		log.WriteErr(err)
	}
	return &casec, total
}

func (s *CaseController) GetCaseAllData(public utils.PublicData, c *gin.Context) *[]CaseController {
	casec := []CaseController{}
	// var total int64
	module, index := s.get_input(public.Input)
	che := public.Checked
	var pubgorm *gorm.DB
	pubgorm = models.GetDb().Table("cases").Where("gid = ? and child_module like ? and indexes like ?", public.Id, utils.LikeJoin(module), "%%"+index+"%%")
	if che.Succ == "" && che.Fail == "" {

	} else if che.Succ == "checked" && che.Fail == "checked" {
		pubgorm = pubgorm.Where("result <> ?", "")
	} else if che.Succ == "checked" && che.Fail == "" {
		pubgorm = pubgorm.Where("result = ?", "T")
	} else if che.Succ == "" && che.Fail == "checked" {
		pubgorm = pubgorm.Where("result = ?", "F")
	}

	if err := pubgorm.Order("id").Find(&casec).Error; err != nil {
		log.WriteErr(err)
	}
	return &casec
}

type forms struct {
	Id          int
	Module      string
	Childmodule string
	Title       string
	Step        []string
	Expect      []string
}

func (s *CaseController) UCase(c *gin.Context) models.Cases {
	f := c.Query("row")
	form := forms{}
	json.Unmarshal([]byte(f), &form)
	step, expect := "", ""
	for i, _ := range form.Step {
		step = fmt.Sprint(step, i+1, ".", form.Step[i])
		expect = fmt.Sprint(expect, i+1, ".", form.Expect[i])
		if i != len(form.Step)-1 {
			step += "\r\n"
			expect += "\r\n"
		}
	}
	cas := models.Cases{
		Id:          form.Id,
		Title:       form.Title,
		Module:      form.Module,
		ChildModule: form.Childmodule,
		Step:        step,
		Expect:      expect,
	}
	return cas
}
func (s *CaseController) ACase(c *gin.Context) models.Cases {
	f := c.Query("row")
	form := forms{}
	json.Unmarshal([]byte(f), &form)
	step, expect := "", ""
	for i, _ := range form.Step {
		step = fmt.Sprint(step, i+1, ".", form.Step[i])
		expect = fmt.Sprint(expect, i+1, ".", form.Expect[i])
		if i != len(form.Step)-1 {
			step += "\r\n"
			expect += "\r\n"
		}
	}
	// cs:=models.Cases{}
	index := 0
	// models.GetDb().Table("cases").Where("gid = ?",form.Id).Order("indexes DESC").First(&cs)
	models.GetDb().Raw("SELECT indexes FROM `cases` WHERE gid = 227 ORDER BY indexes DESC Limit 1").Scan(&index)

	cas := models.Cases{
		// Id:          form.Id,
		Gid:         form.Id,
		Title:       form.Title,
		Module:      form.Module,
		ChildModule: form.Childmodule,
		Step:        step,
		Expect:      expect,
		Indexes:     index + 1,
	}
	return cas
}