hangzhou_mat_manage/sku3d/sku3d/api/a-service-img.go

package api

import (
	"errors"
	"fmt"
	"sku3dweb/db/model"
	"sku3dweb/db/repo"
	"sku3dweb/log"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo/options"
)

func FassiApi(r *GinRouter) {
	r.POSTJWT("/image/create", createImg)
	r.GETJWT("/image/fassi/list", SearchByImg)
	r.GETJWT("/image/list", SearchByFields)
	r.POSTJWT("/image/delete/:id", DeleteImage)
	r.POSTJWT("/image/update", UpdateImage)
	r.GETJWT("/image/detail/:id", DetailImage)
}

func getSerialNum(img *model.MatImage, ctx *repo.RepoSession) (string, error) {
	catId1 := ""
	catId2 := ""
	catId3 := ""
	cat := &model.Category{
		CreateTime: time.Now(),
	}
	find, err := repo.RepoSeachDoc(ctx, &repo.DocSearchOptions{CollectName: repo.CollectionCategory, Query: repo.Map{}, Project: []string{"name", "type", "children", "createTime"}}, cat)
	if !find || err != nil {
		fmt.Println("find category error", err)
		return "", err
	}
	setMap := make(map[string]*model.Category, len(cat.Children)*200)
	for _, s := range cat.Children {
		for _, s1 := range s.Children {
			setMap[s1.IdStr] = s1
			for _, c := range s1.Children {
				setMap[c.IdStr] = c
				for _, cc := range c.Children {
					setMap[cc.IdStr] = cc
				}
			}
		}
	}

	setParentMap := make(map[string]*model.Category, len(cat.Children)*20)
	for _, s := range cat.Children {
		for _, s1 := range s.Children {
			setParentMap[s1.IdStr] = s
			for _, c := range s1.Children {
				setParentMap[c.IdStr] = s1
				for _, cc := range c.Children {
					setParentMap[cc.IdStr] = c
				}
			}
		}
	}
	fmt.Println("len of cate =", len(img.Categories))
	for _, v := range img.Categories {
		c, ok := setMap[v]
		if !ok {
			continue
		}
		p := setParentMap[v]
		fmt.Println("parent->", p.Name, c.Name)
		if p.Name == "商品分类" {
			catId1 = c.CusNum
			fmt.Println("p name", c.CusNum)
			continue
		}
		if p.Name == "产品系列" {
			catId2 = c.CusNum
			fmt.Println("产品系列 name", catId2)
			continue
		}
		if p.Name == "产品用途" {
			catId3 = c.CusNum
			fmt.Println("产品用途 name", c.CusNum)
		}
	}

	if len(catId1) < 1 || len(catId2) < 1 || len(catId3) < 1 {
		fmt.Println("cat err", catId1, catId2, catId3)
		return "", NewError("商品分类/产品系列/产品用途为空")
	}

	filter := bson.M{
		"catId1": catId1,
		"catId2": catId2,
	}

	update := bson.M{
		"$inc": bson.M{"next": 1},
		"$setOnInsert": bson.M{
			"catId1": catId1,
			"catId2": catId2,
		},
	}

	opts := options.FindOneAndUpdate().
		SetUpsert(true).
		SetReturnDocument(options.After)

	var result model.SerialNumer
	col := ctx.Client.GetCollection(repo.CollectionSerialNos)
	err = col.FindOneAndUpdate(ctx.Ctx, filter, update, opts).Decode(&result)
	if err != nil {
		fmt.Println("get SerialNumer error", err)
		return "", fmt.Errorf("failed to get next serial number: %v", err)
	}
	return fmt.Sprintf("%s%s%03d%s", catId1, catId2, result.Next, catId3), nil
}

func UpdateImage(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	var matImage model.MatImage
	err := c.ShouldBindJSON(&matImage)
	if err != nil {
		log.Error(err)
		return nil, err
	}
	if matImage.Id.IsZero() {
		return nil, errors.New("id错误")
	}
	searchMat := &model.MatImage{}
	// 如果更新的是面料图
	found, err := repo.RepoSeachDoc(apictx.CreateRepoCtx(), &repo.DocSearchOptions{
		CollectName: repo.CollectionMatImages,
		Query:       repo.Map{"_id": matImage.Id},
		Project:     []string{"rawImage"},
	}, &searchMat)
	if err != nil {
		return nil, err
	}
	// 没有找到面料数据
	if !found {
		return nil, NewError("未找到数据")
	}
	fmt.Println("updateing ==============")
	fmt.Println(matImage.RawImage, searchMat.RawImage)

	// 更新了面料原图 对应更新fassi 特征数据
	if matImage.RawImage != nil && (searchMat.RawImage == nil || searchMat.RawImage.Url != matImage.RawImage.Url) {
		// 先删除
		// 这里原本可能没有图片特征
		RomoveFassiImage(matImage.Id.Hex())

		// 再新增
		err = AddFassiImage(matImage.Id, matImage.RawImage.Url)
		if err != nil {
			fmt.Println("更新时添加fassi image 错误:", err)
			return nil, errors.New("更新图片搜索特征错误，请重试！")
		}
		fmt.Println("更新fassi image ", matImage.Id.Hex(), err)
	}
	fmt.Println("33333")
	return repo.RepoUpdateSetDoc(apictx.CreateRepoCtx(), repo.CollectionMatImages, matImage.Id.Hex(), &matImage)
}

func DeleteImage(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	id := c.Param("id")
	_, err := RomoveFassiImage(id)
	if err != nil {
		log.Error("删除时删除fassi image 错误:", err)
	}
	return repo.RepoDeleteDoc(apictx.CreateRepoCtx(), repo.CollectionMatImages, id)
}

func DetailImage(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	id := c.Param("id")
	searchMat := &model.MatImage{}
	_, err := repo.RepoSeachDoc(apictx.CreateRepoCtx(), &repo.DocSearchOptions{
		CollectName: repo.CollectionMatImages,
		Query:       repo.Map{"_id": id},
	}, searchMat)
	return searchMat, err
}

func SearchByFields(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	page, size, query := UtilQueryPageSize(c)

	// 查询所有分类
	cates := []*model.Category{}
	repo.RepoDocsSearch(apictx.CreateRepoCtx(), &repo.PageSearchOptions{CollectName: repo.CollectionCategory}, &cates)

	err := parseCategories(query, cates[0])
	if err != nil {
		return nil, err
	}

	pageOption := &repo.PageSearchOptions{
		CollectName: repo.CollectionMatImages,
		Page:        page,
		Size:        size,
		Query:       query,
		// Project:     []string{"nameCn", "createTime", "thumbnail", "price", "from"},
		Sort: bson.M{"createTime": -1},
	}
	return repo.RepoPageSearch(apictx.CreateRepoCtx(), pageOption)
}

func createImg(c *gin.Context, apictx *ApiSession) (interface{}, error) {

	data := &model.MatImage{}
	err := c.ShouldBindJSON(data)
	if err != nil {
		return nil, err
	}
	data.CreateTime = time.Now()
	data.UpdateTime = time.Now()
	data.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
	serial, err := getSerialNum(data, apictx.CreateRepoCtx())
	if err != nil {
		fmt.Println(err)
		return nil, NewError("编号生成失败")
	}
	data.CusNum = serial
	fmt.Println("CusNum=>", serial)

	idstr, err := repo.RepoAddDoc(apictx.CreateRepoCtx(), repo.CollectionMatImages, data)
	if err != nil {
		return nil, err
	}
	imgId, _ := primitive.ObjectIDFromHex(idstr)

	return imgId, AddFassiImage(imgId, data.RawImage.Url)
}

func SearchByImg(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	url := c.Query("url")
	_limit := c.Query("limit")
	_min_score := c.Query("min_score")
	_max_score := c.Query("max_score")
	limit, _ := strconv.Atoi(_limit)
	min_score, _ := strconv.ParseFloat(_min_score, 64)
	max_score, _ := strconv.ParseFloat(_max_score, 64)
	fmt.Println("search url =>: ", url)
	if !strings.Contains(url, "http") {
		return nil, NewError("参数错误")
	}
	images, err := QueryFassiImage(url, limit, min_score, max_score)
	if err != nil {
		return nil, err
	}

	var list = []map[string]interface{}{}
	if len(images) < 1 {
		return list, nil
	}

	var ids = []primitive.ObjectID{}
	for _, item := range images {
		ids = append(ids, item.Id)

	}
	param := &repo.DocSearchOptions{
		CollectName: repo.CollectionMatImages,
		Query:       repo.Map{"_id": bson.M{"$in": ids}},
	}
	err = repo.RepoSeachDocs(apictx.CreateRepoCtx(), param, &list)
	if err != nil {
		return nil, err
	}

	var ImageMap = map[primitive.ObjectID]map[string]interface{}{}
	for _, item := range list {
		ImageMap[item["_id"].(primitive.ObjectID)] = item
	}

	var out = []interface{}{}
	for _, item := range images {
		value := ImageMap[item.Id]
		value["score"] = item.Score
		out = append(out, value)
	}
	return out, nil
}

type IteChildren func(n *model.Category) []string
type FindChild func(n *model.Category, id string) []string

func FindCategoryIds(c *model.Category, parents []string) ([]string, [][]string) {
	out := []string{}
	andOut := [][]string{}
	var allChildren IteChildren
	allChildren = func(n *model.Category) []string {
		ids := []string{}
		if n == nil {
			return ids
		}
		ids = append(ids, n.IdStr)
		if n.Children != nil {
			for _, c := range n.Children {
				cids := allChildren(c)
				if len(cids) > 0 {
					ids = append(ids, cids...)
				}
			}
		}
		return ids
	}
	var findChildrens FindChild
	findChildrens = func(n *model.Category, id string) []string {
		ids := []string{}
		if n == nil {
			return ids
		}

		if n.IdStr == id {
			ids = allChildren(n)
			return ids
		}

		if n.Children == nil {
			return ids
		}

		//查找孩子节点
		for _, c := range n.Children {
			ids = findChildrens(c, id)
			if len(ids) > 0 {
				break
			}
		}
		return ids
	}
	for _, v := range parents {
		for _, catnode := range c.Children {
			extends := findChildrens(catnode, v)
			if len(extends) > 0 {
				andOut = append(andOut, extends)
				out = append(out, extends...)
				break
			}
		}
	}
	return out, andOut
}

func parseCategories(query map[string]interface{}, cateConf *model.Category) error {

	filters := []bson.M{}
	keyfilters := []bson.M{}
	//keyword
	if query["keyword"] != nil {
		keyword := query["keyword"].(string)
		if len(keyword) > 0 {
			keyfilters = append(keyfilters, bson.M{"nameCn": bson.M{"$regex": keyword, "$options": "$i"}})
			keyfilters = append(keyfilters, bson.M{"nameEn": bson.M{"$regex": keyword, "$options": "$i"}})
			keyfilters = append(keyfilters, bson.M{"from": bson.M{"$regex": keyword, "$options": "$i"}})
			keyfilters = append(keyfilters, bson.M{"cusNum": bson.M{"$regex": keyword, "$options": "$i"}})
			filters = append(filters, bson.M{"$or": keyfilters})
		}
		delete(query, "keyword")
	}

	if query["categories"] != nil {
		categories := query["categories"].([]interface{})
		delete(query, "categories")

		//查询所有子内容
		if len(categories) > 0 {
			filterCaties := []string{}
			for _, c := range categories {
				if c != nil {
					if str, ok := c.(string); ok {
						filterCaties = append(filterCaties, str)
					}
				}
			}
			oldextends, andExtends := FindCategoryIds(cateConf, filterCaties)
			fmt.Println("old =>: ", oldextends)
			fmt.Println("and =>: ", andExtends)

			andArrayCons := []bson.M{}
			if len(andExtends) > 0 {
				for _, cateCon := range andExtends {
					if len(cateCon) > 0 {
						andArrayCons = append(andArrayCons, bson.M{"categories": bson.M{"$elemMatch": bson.M{"$in": cateCon}}})
					}
				}
			}
			if len(andArrayCons) > 0 {
				filters = append(filters, bson.M{"$and": andArrayCons})
			}

		}

	}

	if len(filters) > 0 {
		query["$and"] = filters
	}
	fmt.Printf("分类条件 =>: %#v\n", query)

	return nil
}