Michael Chus
20309d1f0e
Renamed module path git.mchus.pro/mchus/quoteforge → git.mchus.pro/mchus/priceforge, renamed package quoteforge → priceforge, moved binary from cmd/qfs to cmd/pfs.
379 lines
9.1 KiB
Go
379 lines
9.1 KiB
Go
package pricing
|
|
|
|
import (
|
|
"strings"
|
|
"time"
|
|
|
|
"git.mchus.pro/mchus/priceforge/internal/config"
|
|
"git.mchus.pro/mchus/priceforge/internal/models"
|
|
"git.mchus.pro/mchus/priceforge/internal/repository"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
type Service struct {
|
|
componentRepo *repository.ComponentRepository
|
|
priceRepo *repository.PriceRepository
|
|
config config.PricingConfig
|
|
db *gorm.DB
|
|
}
|
|
|
|
type RecalculateProgress struct {
|
|
Current int
|
|
Total int
|
|
LotName string
|
|
Updated int
|
|
Errors int
|
|
}
|
|
|
|
func NewService(
|
|
componentRepo *repository.ComponentRepository,
|
|
priceRepo *repository.PriceRepository,
|
|
cfg config.PricingConfig,
|
|
) *Service {
|
|
var db *gorm.DB
|
|
if componentRepo != nil {
|
|
db = componentRepo.DB()
|
|
}
|
|
|
|
return &Service{
|
|
componentRepo: componentRepo,
|
|
priceRepo: priceRepo,
|
|
config: cfg,
|
|
db: db,
|
|
}
|
|
}
|
|
|
|
// GetEffectivePrice returns the current effective price for a component
|
|
// Priority: active override > calculated price > nil
|
|
func (s *Service) GetEffectivePrice(lotName string) (*float64, error) {
|
|
// Check for active override first
|
|
override, err := s.priceRepo.GetPriceOverride(lotName)
|
|
if err == nil && override != nil {
|
|
return &override.Price, nil
|
|
}
|
|
|
|
// Get component metadata
|
|
component, err := s.componentRepo.GetByLotName(lotName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return component.CurrentPrice, nil
|
|
}
|
|
|
|
// CalculatePrice calculates price using the specified method
|
|
func (s *Service) CalculatePrice(lotName string, method models.PriceMethod, periodDays int) (float64, error) {
|
|
if periodDays == 0 {
|
|
periodDays = s.config.DefaultPeriodDays
|
|
}
|
|
|
|
points, err := s.priceRepo.GetPriceHistory(lotName, periodDays)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if len(points) == 0 {
|
|
return 0, nil
|
|
}
|
|
|
|
prices := make([]float64, len(points))
|
|
for i, p := range points {
|
|
prices[i] = p.Price
|
|
}
|
|
|
|
switch method {
|
|
case models.PriceMethodAverage:
|
|
return CalculateAverage(prices), nil
|
|
case models.PriceMethodWeightedMedian:
|
|
return CalculateWeightedMedian(points, periodDays), nil
|
|
case models.PriceMethodMedian:
|
|
fallthrough
|
|
default:
|
|
return CalculateMedian(prices), nil
|
|
}
|
|
}
|
|
|
|
// UpdateComponentPrice recalculates and updates the price for a component
|
|
func (s *Service) UpdateComponentPrice(lotName string) error {
|
|
component, err := s.componentRepo.GetByLotName(lotName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
price, err := s.CalculatePrice(lotName, component.PriceMethod, component.PricePeriodDays)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
now := time.Now()
|
|
if price > 0 {
|
|
component.CurrentPrice = &price
|
|
component.PriceUpdatedAt = &now
|
|
}
|
|
|
|
return s.componentRepo.Update(component)
|
|
}
|
|
|
|
// SetManualPrice sets a manual price override
|
|
func (s *Service) SetManualPrice(lotName string, price float64, reason string, userID uint) error {
|
|
override := &models.PriceOverride{
|
|
LotName: lotName,
|
|
Price: price,
|
|
ValidFrom: time.Now(),
|
|
Reason: reason,
|
|
CreatedBy: userID,
|
|
}
|
|
return s.priceRepo.CreatePriceOverride(override)
|
|
}
|
|
|
|
// UpdatePriceMethod changes the pricing method for a component
|
|
func (s *Service) UpdatePriceMethod(lotName string, method models.PriceMethod, periodDays int) error {
|
|
component, err := s.componentRepo.GetByLotName(lotName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
component.PriceMethod = method
|
|
if periodDays > 0 {
|
|
component.PricePeriodDays = periodDays
|
|
}
|
|
|
|
if err := s.componentRepo.Update(component); err != nil {
|
|
return err
|
|
}
|
|
|
|
return s.UpdateComponentPrice(lotName)
|
|
}
|
|
|
|
// GetPriceStats returns statistics for a component's price history
|
|
func (s *Service) GetPriceStats(lotName string, periodDays int) (*PriceStats, error) {
|
|
if periodDays == 0 {
|
|
periodDays = s.config.DefaultPeriodDays
|
|
}
|
|
|
|
points, err := s.priceRepo.GetPriceHistory(lotName, periodDays)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(points) == 0 {
|
|
return &PriceStats{QuoteCount: 0}, nil
|
|
}
|
|
|
|
prices := make([]float64, len(points))
|
|
for i, p := range points {
|
|
prices[i] = p.Price
|
|
}
|
|
|
|
return &PriceStats{
|
|
QuoteCount: len(points),
|
|
MinPrice: CalculatePercentile(prices, 0),
|
|
MaxPrice: CalculatePercentile(prices, 100),
|
|
MedianPrice: CalculateMedian(prices),
|
|
AveragePrice: CalculateAverage(prices),
|
|
StdDeviation: CalculateStdDev(prices),
|
|
LatestPrice: points[0].Price,
|
|
LatestDate: points[0].Date,
|
|
OldestDate: points[len(points)-1].Date,
|
|
Percentile25: CalculatePercentile(prices, 25),
|
|
Percentile75: CalculatePercentile(prices, 75),
|
|
}, nil
|
|
}
|
|
|
|
type PriceStats struct {
|
|
QuoteCount int `json:"quote_count"`
|
|
MinPrice float64 `json:"min_price"`
|
|
MaxPrice float64 `json:"max_price"`
|
|
MedianPrice float64 `json:"median_price"`
|
|
AveragePrice float64 `json:"average_price"`
|
|
StdDeviation float64 `json:"std_deviation"`
|
|
LatestPrice float64 `json:"latest_price"`
|
|
LatestDate time.Time `json:"latest_date"`
|
|
OldestDate time.Time `json:"oldest_date"`
|
|
Percentile25 float64 `json:"percentile_25"`
|
|
Percentile75 float64 `json:"percentile_75"`
|
|
}
|
|
|
|
// RecalculateAllPrices recalculates prices for all components
|
|
func (s *Service) RecalculateAllPrices() (updated int, errors int) {
|
|
return s.RecalculateAllPricesWithProgress(nil)
|
|
}
|
|
|
|
// RecalculateAllPricesWithProgress recalculates prices and reports progress.
|
|
func (s *Service) RecalculateAllPricesWithProgress(onProgress func(RecalculateProgress)) (updated int, errors int) {
|
|
if s.db == nil {
|
|
return 0, 0
|
|
}
|
|
|
|
// Logic mirrors "Обновить цены" in admin pricing.
|
|
var components []models.LotMetadata
|
|
if err := s.db.Find(&components).Error; err != nil {
|
|
return 0, len(components)
|
|
}
|
|
total := len(components)
|
|
|
|
var allLotNames []string
|
|
_ = s.db.Model(&models.LotMetadata{}).Pluck("lot_name", &allLotNames).Error
|
|
|
|
type lotDate struct {
|
|
Lot string
|
|
Date time.Time
|
|
}
|
|
var latestDates []lotDate
|
|
_ = s.db.Raw(`SELECT lot, MAX(date) as date FROM lot_log GROUP BY lot`).Scan(&latestDates).Error
|
|
lotLatestDate := make(map[string]time.Time, len(latestDates))
|
|
for _, ld := range latestDates {
|
|
lotLatestDate[ld.Lot] = ld.Date
|
|
}
|
|
|
|
var skipped, manual, unchanged int
|
|
now := time.Now()
|
|
current := 0
|
|
|
|
for _, comp := range components {
|
|
current++
|
|
reportProgress := func() {
|
|
if onProgress != nil && (current%10 == 0 || current == total) {
|
|
onProgress(RecalculateProgress{
|
|
Current: current,
|
|
Total: total,
|
|
LotName: comp.LotName,
|
|
Updated: updated,
|
|
Errors: errors,
|
|
})
|
|
}
|
|
}
|
|
|
|
if comp.ManualPrice != nil && *comp.ManualPrice > 0 {
|
|
manual++
|
|
reportProgress()
|
|
continue
|
|
}
|
|
|
|
method := comp.PriceMethod
|
|
if method == "" {
|
|
method = models.PriceMethodMedian
|
|
}
|
|
|
|
var sourceLots []string
|
|
if comp.MetaPrices != "" {
|
|
sourceLots = expandMetaPricesWithCache(comp.MetaPrices, comp.LotName, allLotNames)
|
|
} else {
|
|
sourceLots = []string{comp.LotName}
|
|
}
|
|
if len(sourceLots) == 0 {
|
|
skipped++
|
|
reportProgress()
|
|
continue
|
|
}
|
|
|
|
if comp.PriceUpdatedAt != nil {
|
|
hasNewData := false
|
|
for _, lot := range sourceLots {
|
|
if latestDate, ok := lotLatestDate[lot]; ok && latestDate.After(*comp.PriceUpdatedAt) {
|
|
hasNewData = true
|
|
break
|
|
}
|
|
}
|
|
if !hasNewData {
|
|
unchanged++
|
|
reportProgress()
|
|
continue
|
|
}
|
|
}
|
|
|
|
var prices []float64
|
|
if comp.PricePeriodDays > 0 {
|
|
_ = s.db.Raw(
|
|
`SELECT price FROM lot_log WHERE lot IN ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY) ORDER BY price`,
|
|
sourceLots, comp.PricePeriodDays,
|
|
).Pluck("price", &prices).Error
|
|
} else {
|
|
_ = s.db.Raw(
|
|
`SELECT price FROM lot_log WHERE lot IN ? ORDER BY price`,
|
|
sourceLots,
|
|
).Pluck("price", &prices).Error
|
|
}
|
|
|
|
if len(prices) == 0 && comp.PricePeriodDays > 0 {
|
|
_ = s.db.Raw(`SELECT price FROM lot_log WHERE lot IN ? ORDER BY price`, sourceLots).Pluck("price", &prices).Error
|
|
}
|
|
if len(prices) == 0 {
|
|
skipped++
|
|
reportProgress()
|
|
continue
|
|
}
|
|
|
|
var basePrice float64
|
|
switch method {
|
|
case models.PriceMethodAverage:
|
|
basePrice = CalculateAverage(prices)
|
|
default:
|
|
basePrice = CalculateMedian(prices)
|
|
}
|
|
if basePrice <= 0 {
|
|
skipped++
|
|
reportProgress()
|
|
continue
|
|
}
|
|
|
|
finalPrice := basePrice
|
|
if comp.PriceCoefficient != 0 {
|
|
finalPrice = finalPrice * (1 + comp.PriceCoefficient/100)
|
|
}
|
|
|
|
if err := s.db.Model(&models.LotMetadata{}).
|
|
Where("lot_name = ?", comp.LotName).
|
|
Updates(map[string]interface{}{
|
|
"current_price": finalPrice,
|
|
"price_updated_at": now,
|
|
}).Error; err != nil {
|
|
errors++
|
|
} else {
|
|
updated++
|
|
}
|
|
|
|
reportProgress()
|
|
}
|
|
|
|
if onProgress != nil && total == 0 {
|
|
onProgress(RecalculateProgress{
|
|
Current: 0,
|
|
Total: 0,
|
|
LotName: "",
|
|
Updated: updated,
|
|
Errors: errors,
|
|
})
|
|
}
|
|
|
|
return updated, errors
|
|
}
|
|
|
|
func expandMetaPricesWithCache(metaPrices, excludeLot string, allLotNames []string) []string {
|
|
sources := strings.Split(metaPrices, ",")
|
|
var result []string
|
|
seen := make(map[string]bool)
|
|
|
|
for _, source := range sources {
|
|
source = strings.TrimSpace(source)
|
|
if source == "" || source == excludeLot {
|
|
continue
|
|
}
|
|
|
|
if strings.HasSuffix(source, "*") {
|
|
prefix := strings.TrimSuffix(source, "*")
|
|
for _, lot := range allLotNames {
|
|
if strings.HasPrefix(lot, prefix) && lot != excludeLot && !seen[lot] {
|
|
result = append(result, lot)
|
|
seen[lot] = true
|
|
}
|
|
}
|
|
} else if !seen[source] {
|
|
result = append(result, source)
|
|
seen[source] = true
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|