l_ai_category/ai_test.go

package l_ai_category

import (
	"context"
	"fmt"
	"gitea.cdlsxd.cn/self-tools/l_ai_category/utils_gorm"
	"testing"
	"time"
)

const (
	dns       = "developer:Lsxd@2024@tcp(lsxdpolar.rwlb.rds.aliyuncs.com:3306)/physicalgoods?parseTime=True&loc=Local"
	driver    = "mysql"
	table     = "category"
	modelType = "deepseek-r1-distill-qwen-32b-250120"
	key       = "03320e58-6a0b-4061-a22b-902039f2190d"
	Address   = "http://8.147.107.207:5000/predict"
)

func TestCategoryGoodsSet(t *testing.T) {
	//var wg sync.WaitGroup
	defer clean()
	///path := getPath()
	goods := goodsAll()
	updateChan := make(chan *UpdateLog, len(goods))
	start := time.Now().Unix()
	//wg.Add(len(goods))
	for _, v := range goods {
		//go func(updateChan chan *UpdateLog) {
		//defer wg.Done()
		res, _, err := GetCategoryWithSelf(context.Background(), v.Title, Address)

		if err != nil || res == 0 {
			return
		}
		updateChan <- &UpdateLog{
			GoodsId: v.Id,
			Title:   v.Title,
			CateId:  res,
		}
		//}(updateChan)
	}
	//wg.Wait()
	close(updateChan)
	end := time.Now().Unix()
	fmt.Printf("耗时:%d秒", end-start)
	updateSlice := make([]*UpdateLog, len(updateChan))
	for v := range updateChan {
		updateSlice = append(updateSlice, v)
	}
	for _, v := range updateSlice {
		if v == nil {
			continue
		}
		updateGoodsCate(v)
	}

	t.Log(updateSlice)
}

func updateGoodsCate(data *UpdateLog) {
	db.Table("goods_category_relation").Where("goods_id = ?", data.GoodsId).Updates(map[string]interface{}{"category_id": data.CateId})
	db.Table("goods").Where("id = ?", data.GoodsId).Updates(map[string]interface{}{"brand_category_check": 3})
}

type UpdateLog struct {
	GoodsId int    `json:"goods_id"`
	Title   string `json:"title"`
	CateId  int    `json:"cate_id"`
}
type CategoryPhy struct {
	Id       int    `json:"id"`
	Name     string `json:"name"`
	Level    int    `json:"level"`
	ParentId int    `json:"parent_id"`
}

type Goods struct {
	Id                 int    `json:"id"`
	Title              string `json:"title"`
	BrandCateGoryCheck int    `json:"brand_category_check"`
}

func goodsAll() (data []Goods) {
	var (
		row Goods
		err error
	)
	rows, _ := db.Raw("SELECT id,title  FROM `goods`  order by id desc limit 1000 offset 3156").Rows() //where brand_category_check=4
	defer rows.Close()
	for rows.Next() {
		err = db.ScanRows(rows, &row)
		if err != nil {
			panic(err)
		}
		data = append(data, row)
	}
	return
}

func getPath() []map[int][]*CategoryDic {
	cates := cateAll()
	var (
		cateLevelPath = make([]map[int][]*CategoryDic, 3)
	)
	for _, v := range cates {
		if cateLevelPath[v.Level-1] == nil {
			cateLevelPath[v.Level-1] = make(map[int][]*CategoryDic)
		}
		if _, ex := cateLevelPath[v.Level-1][v.ParentId]; !ex {
			cateLevelPath[v.Level-1][v.ParentId] = make([]*CategoryDic, 0)
		}
		cateLevelPath[v.Level-1][v.ParentId] = append(cateLevelPath[v.Level-1][v.ParentId], &CategoryDic{
			Category{
				Id:    v.Id,
				Name:  v.Name,
				Level: v.Level,
			}})
	}
	return cateLevelPath
}

func getPath2() []Category {
	cates := cateAll()
	var (
		level1Map   = make(map[int]Category)
		level2Map   = make(map[int]Category)
		level3Slice = make([]Category, 0)
	)

	for _, v := range cates {
		switch v.Level {
		case 1:
			level1Map[v.Id] = Category{
				Id:   v.Id,
				Name: v.Name,
			}
		case 2:
			level2Map[v.Id] = Category{
				Id:   v.Id,
				Name: v.Name,
				Pid:  v.ParentId,
			}
		case 3:
			cateName := fmt.Sprintf("%s/%s/%s", level1Map[level2Map[v.ParentId].Pid].Name, level2Map[v.ParentId].Name, v.Name)
			level3Slice = append(level3Slice, Category{
				Id:   v.Id,
				Name: cateName,
			})
		}

	}
	return level3Slice
}

func getPath3() (map[int]Category, map[string]Category) {
	cates := cateAll()
	var (
		level1Map = make(map[int]Category)
		level2Map = make(map[int]Category)
		level3Map = make(map[string]Category)
	)

	for _, v := range cates {
		switch v.Level {
		case 1:

			level2Map[v.Id] = Category{
				Name: v.Name,
			}
		case 2:
			cate_name := fmt.Sprintf("%s/%s", level1Map[v.ParentId].Name, v.Name)
			level2Map[v.Id] = Category{
				Id:   v.Id,
				Name: cate_name,
				Pid:  v.ParentId,
			}
		case 3:
			if _, ex := level3Map[v.Name]; !ex {
				level3Map[v.Name] = Category{
					Id:   v.Id,
					Pids: map[int]int{v.Id: v.ParentId},
					Name: v.Name,
				}
			} else {
				level3Map[v.Name].Pids[v.Id] = v.ParentId
			}

		}

	}
	return level2Map, level3Map
}

func cateAll() (data []CategoryPhy) {
	var (
		row CategoryPhy
	)

	rows, _ := db.Raw(fmt.Sprintf("SELECT id,name,level,parent_id  FROM `%s`", table)).Rows()
	defer rows.Close()
	for rows.Next() {
		err := db.ScanRows(rows, &row)
		if err != nil {
			panic(err)
		}
		data = append(data, row)
	}
	return
}

var db, _, clean = utils_gorm.DB(driver, dns)