lti-api/internal/utils/recording/util.recording.go

package recording

import (
	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/validations"
)

func MapBodyWeights(recordingID uint, items []validation.BodyWeight) []entity.RecordingBW {
	if len(items) == 0 {
		return nil
	}

	result := make([]entity.RecordingBW, 0, len(items))
	for _, item := range items {
		totalWeight := item.TotalWeight
		if totalWeight <= 0 {
			totalWeight = item.AvgWeight * item.Qty
		}

		result = append(result, entity.RecordingBW{
			RecordingId: recordingID,
			AvgWeight:   item.AvgWeight,
			Qty:         item.Qty,
			TotalWeight: totalWeight,
		})
	}
	return result
}

func MapStocks(recordingID uint, items []validation.Stock) []entity.RecordingStock {
	if len(items) == 0 {
		return nil
	}

	result := make([]entity.RecordingStock, 0, len(items))
	for _, item := range items {
		usagePtr := new(float64)
		*usagePtr = item.Qty
		pending := item.PendingQty
		if pending == nil {
			pending = new(float64)
		}
		result = append(result, entity.RecordingStock{
			RecordingId:        recordingID,
			ProductWarehouseId: item.ProductWarehouseId,
			UsageQty:           usagePtr,
			PendingQty:         pending,
		})
	}
	return result
}

func MapDepletions(recordingID uint, items []validation.Depletion) []entity.RecordingDepletion {
	if len(items) == 0 {
		return nil
	}

	result := make([]entity.RecordingDepletion, 0, len(items))
	for _, item := range items {
		result = append(result, entity.RecordingDepletion{
			RecordingId:        recordingID,
			ProductWarehouseId: item.ProductWarehouseId,
			Qty:                item.Qty,
		})
	}
	return result
}

func MapEggs(recordingID uint, createdBy uint, items []validation.Egg) []entity.RecordingEgg {
	if len(items) == 0 {
		return nil
	}

	result := make([]entity.RecordingEgg, 0, len(items))
	for _, item := range items {
		result = append(result, entity.RecordingEgg{
			RecordingId:        recordingID,
			ProductWarehouseId: item.ProductWarehouseId,
			Qty:                item.Qty,
			CreatedBy:          createdBy,
		})
	}
	return result
}

func ToGrams(weight float64) float64 {
	if weight <= 0 {
		return 0
	}
	if weight < 10 {
		return weight * 1000
	}
	return weight
}

func GramsToKg(grams float64) float64 {
	if grams <= 0 {
		return 0
	}
	return grams / 1000
}