assets/service/procurement/purchase_order_item_service.go

package service

import (
	"assets/dao/procurement"
	"assets/model/dto/procurement"
	"assets/model/entity/procurement"
	"context"

	"github.com/gogf/gf/v2/errors/gerror"
	"go.mongodb.org/mongo-driver/v2/bson"
)

type purchaseOrderItem struct{}

// PurchaseOrderItem 采购订单明细服务
var PurchaseOrderItem = new(purchaseOrderItem)

// CreatePurchaseOrderItem 创建采购订单明细
func (s *purchaseOrderItem) CreatePurchaseOrderItem(ctx context.Context, req *dto.CreatePurchaseOrderItemReq) (*dto.CreatePurchaseOrderItemRes, error) {
	// 自动计算总价（如果未提供）
	if req.TotalPrice == 0 {
		req.TotalPrice = req.UnitPrice * req.Quantity
	}
	// 默认折扣价为单价（如果未提供）
	if req.DiscountPrice == 0 {
		req.DiscountPrice = req.UnitPrice
	}

	// 保存到数据库
	ids, err := dao.PurchaseOrderItem.Insert(ctx, req)
	if err != nil {
		return nil, gerror.Wrap(err, "创建采购订单明细失败")
	}

	var id *bson.ObjectID
	if len(ids) > 0 {
		if objectID, ok := ids[0].(bson.ObjectID); ok {
			id = &objectID
		}
	}

	return &dto.CreatePurchaseOrderItemRes{ID: id}, nil
}

// BatchCreatePurchaseOrderItems 批量创建采购订单明细
func (s *purchaseOrderItem) BatchCreatePurchaseOrderItems(ctx context.Context, req *dto.BatchCreatePurchaseOrderItemsReq) (*dto.BatchCreatePurchaseOrderItemsRes, error) {
	// 自动计算总价和设置默认折扣价
	for i := range req.Items {
		if req.Items[i].TotalPrice == 0 {
			req.Items[i].TotalPrice = req.Items[i].UnitPrice * req.Items[i].Quantity
		}
		if req.Items[i].DiscountPrice == 0 {
			req.Items[i].DiscountPrice = req.Items[i].UnitPrice
		}
	}

	// 保存到数据库
	ids, err := dao.PurchaseOrderItem.BatchInsert(ctx, req)
	if err != nil {
		return nil, gerror.Wrap(err, "批量创建采购订单明细失败")
	}

	// 转换ID列表
	idList := make([]*bson.ObjectID, 0, len(ids))
	for _, id := range ids {
		if objectID, ok := id.(bson.ObjectID); ok {
			idList = append(idList, &objectID)
		}
	}

	return &dto.BatchCreatePurchaseOrderItemsRes{IDs: idList}, nil
}

// UpdatePurchaseOrderItem 更新采购订单明细
func (s *purchaseOrderItem) UpdatePurchaseOrderItem(ctx context.Context, req *dto.UpdatePurchaseOrderItemReq) error {
	// 自动计算总价（如果提供了数量和单价）
	if req.Quantity > 0 && req.UnitPrice > 0 && req.TotalPrice == 0 {
		req.TotalPrice = req.UnitPrice * req.Quantity
	}

	// 更新到数据库
	err := dao.PurchaseOrderItem.Update(ctx, req)
	if err != nil {
		return gerror.Wrap(err, "更新采购订单明细失败")
	}

	return nil
}

// DeletePurchaseOrderItem 删除采购订单明细
func (s *purchaseOrderItem) DeletePurchaseOrderItem(ctx context.Context, id *bson.ObjectID) error {
	return dao.PurchaseOrderItem.DeleteFake(ctx, id)
}

// GetPurchaseOrderItem 获取采购订单明细详情
func (s *purchaseOrderItem) GetPurchaseOrderItem(ctx context.Context, id *bson.ObjectID) (*dto.GetPurchaseOrderItemRes, error) {
	item, err := dao.PurchaseOrderItem.GetOne(ctx, id)
	if err != nil {
		return nil, gerror.Wrap(err, "获取采购订单明细失败")
	}

	// 转换为响应
	res := &dto.GetPurchaseOrderItemRes{
		ID:              item.Id,
		OrderId:         item.OrderId,
		AssetId:         item.AssetId,
		AssetSkuId:      item.AssetSkuId,
		ProductName:     item.ProductName,
		Specification:   item.Specification,
		Brand:           item.Brand,
		Quantity:        item.Quantity,
		Unit:            item.Unit,
		UnitPrice:       item.UnitPrice,
		TotalPrice:      item.TotalPrice,
		DiscountPrice:   item.DiscountPrice,
		RequirementDesc: item.RequirementDesc,
		DeliveryAddress: item.DeliveryAddress,
		CreatedAt:       item.CreatedAt.Format("2006-01-02 15:04:05"),
		UpdatedAt:       item.UpdatedAt.Format("2006-01-02 15:04:05"),
	}

	return res, nil
}

// ListPurchaseOrderItems 获取采购订单明细列表
func (s *purchaseOrderItem) ListPurchaseOrderItems(ctx context.Context, req *dto.ListPurchaseOrderItemsReq) (*dto.ListPurchaseOrderItemsRes, error) {
	// 获取数据
	items, total, err := dao.PurchaseOrderItem.List(ctx, req)
	if err != nil {
		return nil, gerror.Wrap(err, "获取采购订单明细列表失败")
	}

	// 转换为响应
	listItems := make([]*dto.PurchaseOrderItemListItem, 0, len(items))
	for _, item := range items {
		listItems = append(listItems, &dto.PurchaseOrderItemListItem{
			ID:              item.Id,
			OrderId:         item.OrderId,
			AssetId:         item.AssetId,
			AssetSkuId:      item.AssetSkuId,
			ProductName:     item.ProductName,
			Specification:   item.Specification,
			Brand:           item.Brand,
			Quantity:        item.Quantity,
			Unit:            item.Unit,
			UnitPrice:       item.UnitPrice,
			TotalPrice:      item.TotalPrice,
			DiscountPrice:   item.DiscountPrice,
			RequirementDesc: item.RequirementDesc,
			DeliveryAddress: item.DeliveryAddress,
			CreatedAt:       item.CreatedAt.Format("2006-01-02 15:04:05"),
			UpdatedAt:       item.UpdatedAt.Format("2006-01-02 15:04:05"),
		})
	}

	return &dto.ListPurchaseOrderItemsRes{
		List:  listItems,
		Total: total,
	}, nil
}

// ListByOrderId 根据订单ID获取采购订单明细列表
func (s *purchaseOrderItem) ListByOrderId(ctx context.Context, orderId *bson.ObjectID) ([]*entity.PurchaseOrderItem, error) {
	items, err := dao.PurchaseOrderItem.ListByOrderId(ctx, orderId)
	if err != nil {
		return nil, gerror.Wrap(err, "获取订单明细列表失败")
	}
	return items, nil
}

// GenerateTestData 生成测试数据
func (s *purchaseOrderItem) GenerateTestData(ctx context.Context) error {

	testData := &dto.BatchCreatePurchaseOrderItemsReq{}

	_, err := s.BatchCreatePurchaseOrderItems(ctx, testData)
	if err != nil {
		return gerror.Wrap(err, "生成测试数据失败")
	}

	return nil
}