assets/service/asset/asset_service.go

package service

import (
	"assets/consts/stock"
	dao "assets/dao/asset"
	dto "assets/model/dto/asset"
	enumDto "assets/model/dto/enum"
	entity "assets/model/entity/asset"
	service "assets/service/enum"
	"context"
	"errors"

	"gitea.com/red-future/common/http"
	"gitea.com/red-future/common/utils"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"

	"gitea.com/red-future/common/beans"
)

type asset struct{}

// Asset 资产服务
var Asset = new(asset)

// Create 创建资产
func (s *asset) Create(ctx context.Context, req *dto.CreateAssetReq) (res *dto.CreateAssetRes, err error) {
	count, err := dao.Asset.Count(ctx, &dto.ListAssetReq{Name: req.Name})
	if err != nil {
		return
	}
	if count > 0 {
		return nil, errors.New("资产名称已存在")
	}
	// 检查是否是超级管理员
	isSuperAdmin := false
	// 获取当前请求的 headers 并传递到下游
	headers := make(map[string]string)
	if r := g.RequestFromCtx(ctx); r != nil {
		for k, v := range r.Request.Header {
			if len(v) > 0 {
				headers[k] = v[0]
			}
		}
	}
	if err = http.Get(ctx, "admin-go/api/v1/system/user/checkIsSuperAdmin", headers, &isSuperAdmin); err != nil {
		return
	}
	if !isSuperAdmin {
		req.StockMode = stock.StockModeDetail
	} else {
		req.TenantModuleType = beans.TenantModuleTypePlatform
	}

	// 插入数据库
	id, err := dao.Asset.Insert(ctx, req)
	if err != nil {
		return
	}
	res = &dto.CreateAssetRes{
		Id: id,
	}
	return
}

// List 获取资产列表
func (s *asset) List(ctx context.Context, req *dto.ListAssetReq) (res *dto.ListAssetRes, err error) {
	assetList, total, err := dao.Asset.List(ctx, req)
	if err != nil {
		return
	}
	res = &dto.ListAssetRes{
		Total: total,
	}
	err = gconv.Struct(assetList, &res.List)
	return
}

// GetOne 获取单个资产
func (s *asset) GetOne(ctx context.Context, req *dto.GetAssetReq) (res *dto.GetAssetRes, err error) {
	var assetOne *entity.Asset
	if assetOne, err = dao.Asset.GetOne(ctx, req); err != nil {
		return
	}
	var assetListItem *entity.Asset
	if err = gconv.Struct(assetOne, &assetListItem); err != nil {
		return
	}
	getCategoryRes, err := dao.Category.GetOne(ctx, &dto.GetCategoryReq{
		Id: assetOne.CategoryId,
	})
	if err != nil {
		return
	}
	res = &dto.GetAssetRes{
		Asset:        assetListItem,
		CategoryName: getCategoryRes.Name,
	}
	res.ImgAddressPrefix, err = utils.GetFileAddressPrefix(ctx)
	if err != nil {
		return
	}
	return
}

// GetAssetAndSku 获取资产和Sku详情
func (s *asset) GetAssetAndSku(ctx context.Context, req *dto.GetAssetAndSkuReq) (res *dto.GetAssetAndSkuRes, err error) {
	var updateReq *dto.GetAssetReq
	if err = gconv.Struct(req, &updateReq); err != nil {
		return
	}
	assetOne, err := dao.Asset.GetOne(ctx, updateReq)
	if err != nil {
		return
	}
	var assetListItem *entity.Asset
	if err = gconv.Struct(assetOne, assetListItem); err != nil {
		return
	}
	moduleType, err := service.Enum.GetTenantModuleType(ctx, &enumDto.GetTenantModuleTypeReq{AssetId: assetOne.Id})
	if err != nil {
		return
	}
	skus, _, err := dao.AssetSku.List(ctx, &dto.ListAssetSkuReq{AssetId: assetOne.Id})
	if err != nil {
		return
	}
	var assetSkuListResItem []dto.AssetSkuItem
	if err = gconv.Structs(skus, assetSkuListResItem); err != nil {
		return
	}
	res = &dto.GetAssetAndSkuRes{
		Asset:            assetListItem,
		Skus:             assetSkuListResItem,
		TenantModuleType: moduleType.Options,
	}
	url, err := utils.GetFileAddressPrefix(ctx)
	if err != nil {
		return
	}
	res.ImgAddressPrefix = url
	return
}

// Update 更新资产
func (s *asset) Update(ctx context.Context, req *dto.UpdateAssetReq) (err error) {
	_, err = dao.Asset.Update(ctx, req)
	return
}

// UpdateStatus 更新资产状态
func (s *asset) UpdateStatus(ctx context.Context, req *dto.UpdateAssetStatusReq) (err error) {
	var updateReq *dto.UpdateAssetReq
	if err = gconv.Struct(req, &updateReq); err != nil {
		return err
	}
	_, err = dao.Asset.Update(ctx, updateReq)
	return
}

// Delete 删除资产
func (s *asset) Delete(ctx context.Context, req *dto.DeleteAssetReq) (err error) {
	_, err = dao.Asset.Delete(ctx, req)
	return
}