hangzhou_mat_manage/sku3d/sku3d/api/service-asset-updator.go

package api

import (
	"fmt"
	"sku3dweb/bus"
	"sku3dweb/db/model"
	"time"

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

func regAssetUpdator(router *GinRouter) {

	router.POSTJWT("/asset/user/:assetType/header", updateUserAssetComm)
	router.POSTJWT("/asset/team/:assetType/header", updateTeamAssetComm)
	router.POSTJWT("/asset/company/:assetType/header", updateCompanyAssetComm)

	//目前只支持自己的
	router.POSTJWT("/asset/user/:assetType/retreat", retreatAssetPack)

	//目前只支持自己的
	router.POSTJWT("/shadow/:scope/:assetType/:id", createAssetShadow)

	router.POSTJWT("/asset/user/:assetType/create", createAssetPack)
	// !20240411 迁移到asset/:scope/:assetType/insert scope包括user,team,company
	// router.POSTJWT("/asset/user/:assetType/insert", insertAssetPack)

	router.POSTJWT("/asset/user/:assetType/insert", insertUserAsset)
	router.POSTJWT("/asset/team/:assetType/insert", insertTeamAsset)
	router.POSTJWT("/asset/company/:assetType/insert", insertCompanyAsset)

	router.POSTJWT("/company/publish", companyPublish)
}

func insertUserAsset(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	return insertScopeAsset(c, apictx, "user")
}

func insertTeamAsset(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	return insertScopeAsset(c, apictx, "team")
}

func insertCompanyAsset(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	return insertScopeAsset(c, apictx, "company")
}

func createAssetPack(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	assetType := c.Param("assetType")
	if len(assetType) < 1 {
		return nil, fmt.Errorf("参数错误")
	}

	isCompany := model.USERTYPE_COMPANY == apictx.User.UserType
	isSku3d := apictx.User.Parent == model.SKU3D_USERID
	req := &bus.UpdateCommReq{Db: Sku3dDbName}

	if isAssetPack(assetType) {
		req.Pack = &comm.AssetPackage{}
		err := c.ShouldBindJSON(req.Pack)
		if err != nil {
			return nil, err
		}
		req.Pack.CreateTime = time.Now()
		req.Pack.UpdateTime = time.Now()
		req.Pack.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
		req.Pack.OwnerId, _ = primitive.ObjectIDFromHex(apictx.User.Parent)
		req.Pack.OwnerType = "user"
		if req.Pack.Source != nil {
			if assetType == "shoe" || assetType == "shoes" {
				req.Pack.Source.ViewMode = "scene"
			} else {
				req.Pack.Source.ViewMode = "prod"
			}

		}

		transTask := req.Pack.TransTask
		if comm.TransTaskIsNotEmpty(transTask) {
			req.Pack.Source = nil
		}

	} else if isFabric3d(assetType) {
		req.Mat3d = &comm.AssetMatGroup{}
		err := c.ShouldBindJSON(req.Mat3d)
		if err != nil {
			return nil, err
		}
		req.Mat3d.Enable = BoolValue(false)
		req.Mat3d.AssetState = comm.AssetState_Succ
		req.Mat3d.CreateTime = time.Now()
		req.Mat3d.UpdateTime = time.Now()
		req.Mat3d.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
		req.Mat3d.OwnerId, _ = primitive.ObjectIDFromHex(apictx.User.Parent)
		req.Mat3d.OwnerType = "user"
	} else if isAssetImage(assetType) {
		req.Img = &comm.AssetImage{}
		err := c.ShouldBindJSON(req.Img)
		if err != nil {
			return nil, err
		}
		req.Img.Enable = BoolValue(false)
		req.Img.AssetState = comm.AssetState_Succ
		req.Img.CreateTime = time.Now()
		req.Img.UpdateTime = time.Now()
		req.Img.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
		req.Img.OwnerId, _ = primitive.ObjectIDFromHex(apictx.User.Parent)
		req.Img.OwnerType = "user"
	} else if isEnv3d(assetType) {
		req.Env3d = &comm.AssetEnv3dHdr{}
		err := c.ShouldBindJSON(req.Env3d)
		if err != nil {
			return nil, err
		}
		req.Env3d.Enable = BoolValue(false)
		req.Env3d.AssetState = comm.AssetState_Succ
		req.Env3d.CreateTime = time.Now()
		req.Env3d.UpdateTime = time.Now()
		req.Env3d.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
		req.Env3d.OwnerId, _ = primitive.ObjectIDFromHex(apictx.User.Parent)
		req.Env3d.OwnerType = "user"
	} else if isOtherMat(assetType) {
		req.OtherMat = &comm.AssetMat{}
		err := c.ShouldBindJSON(req.OtherMat)
		if err != nil {
			return nil, err
		}
		req.OtherMat.Enable = BoolValue(false)
		req.OtherMat.AssetState = comm.AssetState_Succ
		req.OtherMat.CreateTime = time.Now()
		req.OtherMat.UpdateTime = time.Now()
		req.OtherMat.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
		req.OtherMat.OwnerId, _ = primitive.ObjectIDFromHex(apictx.User.Parent)
		req.OtherMat.OwnerType = "user"
	}

	srcColl := getAssetTypeCollectin(isCompany, isSku3d, "user", assetType)
	req.Coll = srcColl
	fmt.Println("createAssetPack===>:\n", req)

	ret, err := bus.BusTreeAssetCreate(req)
	fmt.Printf("crate id%v,err:%v", ret, err)

	return ret, err
}

func insertScopeAsset(c *gin.Context, apictx *ApiSession, scope string) (interface{}, error) {

	isCompany := model.USERTYPE_COMPANY == apictx.User.UserType
	isSku3d := apictx.User.Parent == model.SKU3D_USERID

	req := &bus.UpdateCommReq{Db: Sku3dDbName}
	assetType := c.Param("assetType")

	if isAssetPack(assetType) {
		req.Pack = &comm.AssetPackage{}
		err := c.ShouldBindJSON(req.Pack)
		if err != nil {
			return nil, err
		}
		req.Pack.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
		// !ownerId 如果是team,company,则是team,parent的id
		// !前端做了相关处理,这里不需要再处理
		// req.Pack.OwnerId, _ = primitive.ObjectIDFromHex(apictx.User.Parent)
		req.Pack.OwnerType = scope

		if isShoePack(assetType) && req.Pack.Source != nil {
			req.Pack.Source.ViewMode = "scene"
		}
	} else if isFabric3d(assetType) {
		req.Mat3d = &comm.AssetMatGroup{}
		err := c.ShouldBindJSON(req.Mat3d)
		if err != nil {
			return nil, err
		}
		req.Mat3d.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
		// req.Pack.OwnerId, _ = primitive.ObjectIDFromHex(apictx.User.Parent)
		req.Mat3d.OwnerType = scope

	} else if isAssetImage(assetType) {
		req.Img = &comm.AssetImage{}
		err := c.ShouldBindJSON(req.Img)
		if err != nil {
			return nil, err
		}
		req.Img.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
		// req.Pack.OwnerId, _ = primitive.ObjectIDFromHex(apictx.User.Parent)
		req.Img.OwnerType = scope

	} else if isOtherMat(assetType) {
		req.OtherMat = &comm.AssetMat{}
		err := c.ShouldBindJSON(req.OtherMat)
		if err != nil {
			return nil, err
		}
		req.OtherMat.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
		// req.Pack.OwnerId, _ = primitive.ObjectIDFromHex(apictx.User.Parent)
		req.OtherMat.OwnerType = scope

	}

	srcColl := getAssetTypeCollectin(isCompany, isSku3d, scope, assetType)
	req.Coll = srcColl

	return bus.BusTreeInsertAssetPack(Sku3dDbName, srcColl, &bus.AssetInsertReq{
		DbName:   Sku3dDbName,
		Coll:     srcColl,
		Pack:     req.Pack,
		Mat3d:    req.Mat3d,
		Img:      req.Img,
		OtherMat: req.OtherMat,
	})
}

func insertAssetPack(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	assetType := c.Param("assetType")
	isCompany := model.USERTYPE_COMPANY == apictx.User.UserType
	isSku3d := apictx.User.Parent == model.SKU3D_USERID
	if !isAssetPack(assetType) {
		return nil, fmt.Errorf("不支持的类型" + assetType)
	}

	pack := &comm.AssetPackage{}
	err := c.ShouldBindJSON(pack)
	if err != nil {
		return nil, err
	}

	pack.CreateTime = time.Now()
	pack.UpdateTime = time.Now()
	pack.UserId, _ = primitive.ObjectIDFromHex(apictx.User.ID)
	pack.OwnerId, _ = primitive.ObjectIDFromHex(apictx.User.Parent)
	pack.OwnerType = "user"
	if isShoePack(assetType) {
		pack.Source.ViewMode = "scene"
	} else {
		pack.Source.ViewMode = "prod"
	}

	srcColl := getAssetTypeCollectin(isCompany, isSku3d, "user", assetType)

	return bus.BusTreeAssetPackAdd(Sku3dDbName, srcColl, pack)
}

func retreatAssetPack(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	assetType := c.Param("assetType")
	scope := "user"
	if len(assetType) < 1 || len(scope) < 1 {
		return nil, fmt.Errorf("参数错误")
	}

	if !isAssetPack(assetType) {
		return nil, fmt.Errorf("不支持的类型")
	}

	isCompany := model.USERTYPE_COMPANY == apictx.User.UserType
	isSku3d := apictx.User.Parent == model.SKU3D_USERID
	req := &bus.UpdateCommReq{Db: Sku3dDbName}
	req.Pack = &comm.AssetPackage{}
	err := c.ShouldBindJSON(req.Pack)
	if err != nil {
		return nil, err
	}

	req.Pack.Source = &comm.Queen3dPackageSource{} //清空数据,只需要一个Id参数就够了
	srcColl := getAssetTypeCollectin(isCompany, isSku3d, scope, assetType)
	req.Coll = srcColl

	return req, bus.BusTreeAssetReProcess(req)
}

func createAssetShadow(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	assetType := c.Param("assetType")
	scope := c.Param("scope")
	id := c.Param("id")
	if len(assetType) < 1 || len(scope) < 1 || len(id) < 1 {
		return nil, fmt.Errorf("参数错误")
	}
	if !isAssetPack(assetType) {
		return nil, fmt.Errorf("不支持的类型")
	}

	body := struct {
		Width int
		Scale int
	}{}
	err := c.ShouldBindJSON(&body)
	if err != nil {
		return nil, err
	}
	isCompany := model.USERTYPE_COMPANY == apictx.User.UserType
	isSku3d := apictx.User.Parent == model.SKU3D_USERID
	req := &bus.UpdateCommReq{Db: Sku3dDbName}
	srcColl := getAssetTypeCollectin(isCompany, isSku3d, scope, assetType)

	return req, bus.BusTreeAssetCreateShadow(&bus.CreateShadowReq{
		Db:    Sku3dDbName,
		Coll:  srcColl,
		Id:    id,
		Width: body.Width,
		Scale: body.Scale,
	})
}

func updateUserAssetComm(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	return updateAssetComm(c, apictx, "user")
}

func updateTeamAssetComm(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	return updateAssetComm(c, apictx, "team")
}

func updateCompanyAssetComm(c *gin.Context, apictx *ApiSession) (interface{}, error) {
	return updateAssetComm(c, apictx, "company")
}

func updateAssetComm(c *gin.Context, apictx *ApiSession, scope string) (interface{}, error) {

	isCompany := model.USERTYPE_COMPANY == apictx.User.UserType
	isSku3d := apictx.User.Parent == model.SKU3D_USERID

	req := &bus.UpdateCommReq{Db: Sku3dDbName}
	assetType := c.Param("assetType")

	if isAssetPack(assetType) {
		req.Pack = &comm.AssetPackage{}
		err := c.ShouldBindJSON(req.Pack)
		if err != nil {
			return nil, err
		}

		if isShoePack(assetType) && req.Pack.Source != nil {
			req.Pack.Source.ViewMode = "scene"
		}
	} else if isFabric3d(assetType) {
		req.Mat3d = &comm.AssetMatGroup{}
		err := c.ShouldBindJSON(req.Mat3d)
		if err != nil {
			return nil, err
		}
	} else if isAssetImage(assetType) {
		req.Img = &comm.AssetImage{}
		err := c.ShouldBindJSON(req.Img)
		if err != nil {
			return nil, err
		}
	}

	srcColl := getAssetTypeCollectin(isCompany, isSku3d, scope, assetType)
	req.Coll = srcColl

	return req, bus.BusTreeAssetUpdate(req)
}

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

	body := &struct {
		AssetType string
		Id        string
		Publish   bool
	}{}
	err := c.ShouldBindJSON(body)
	if err != nil {
		return nil, fmt.Errorf("参数错误")
	}

	isCompany := true
	isSku3d := apictx.User.Parent == model.SKU3D_USERID

	req := &bus.UpdateCommReq{Db: Sku3dDbName}
	assetType := body.AssetType
	if isAssetPack(assetType) {
		req.Pack = &comm.AssetPackage{}
		req.Pack.Id, _ = primitive.ObjectIDFromHex(body.Id)
		req.Pack.Enable = &body.Publish

	} else if isFabric3d(assetType) {
		req.Mat3d = &comm.AssetMatGroup{}
		req.Mat3d.Id, _ = primitive.ObjectIDFromHex(body.Id)
		req.Mat3d.Enable = &body.Publish

	} else if isAssetImage(assetType) {
		req.Img = &comm.AssetImage{}
		req.Img.Id, _ = primitive.ObjectIDFromHex(body.Id)
		req.Img.Enable = &body.Publish
	}

	srcColl := getAssetTypeCollectin(isCompany, isSku3d, "company", assetType)
	req.Coll = srcColl

	return req, bus.BusTreeAssetUpdate(req)
}