gdd_service.go

package services

import (
	"dawn-weather/models"
	"dawn-weather/models/enums"
	"dawn-weather/persistence"
	"dawn-weather/persistence/entities"
	"time"
)

func calculateGdd(minTemp float64, maxTemp float64, product enums.Product) float64 {
	if product.Name == "CORN" {
		if minTemp < 50 {
			minTemp = 50
		}
		if minTemp > 86 {
			minTemp = 86
		}

		if maxTemp < 50 {
			maxTemp = 50
		}
		if maxTemp > 86 {
			maxTemp = 86
		}
	}
	mean := (maxTemp + minTemp) / 2.0
	value := mean - product.BaseTemp
	if product.Name == "CORN" {
		return value
	}
	if value < 0 {
		value = 0
	}
	return value
}
func CalculateGddValues(minTemps []float64, maxTemps []float64, product enums.Product, accumulate bool) []float64 {
	var returnList []float64
	for i := 0; i < len(minTemps); i++ {
		value := calculateGdd(minTemps[i], maxTemps[i], product)
		if accumulate && i > 0 {
			value += returnList[len(returnList)-1]
		}
		returnList = append(returnList, value)
	}
	return returnList
}

func CalculateNormalGddValues(base []float64, product enums.Product, accumulate bool) []float64 {
	var returnList []float64
	for i := 0; i < len(base); i++ {
		value := base[i] - product.BaseTemp
		if value < 0 {
			value = 0
		}
		if accumulate && i > 0 {
			value += returnList[len(returnList)-1]
		}
		returnList = append(returnList, value)
	}
	return returnList
}

func GetGddValues(request models.GddRequest) models.GddResponse {
	product := enums.GetProductFromString(request.Product)
	var gdds entities.Gdd
	if request.Year == time.Now().Year() {
		gdds = persistence.CurrentGddFindFirstByYearAndLocation(request.BuildLocation())
	} else {
		gdds = persistence.GddFindFirstByYearAndLocation(request.Year, request.BuildLocation())
	}
	returnGdds := models.GddResponse{
		Product:          product.Name,
		NearestLatitude:  gdds.Location.Coordinates[1],
		NearestLongitude: gdds.Location.Coordinates[0],
		GddValues:        CalculateGddValues(gdds.MinTemps, gdds.MaxTemps, product, request.Accumulate),
		LastDate: gdds.LastDate,
	}
	return returnGdds
}

func GetNormalValues(request models.GddRequest) models.GddResponse {
	product := enums.GetProductFromString(request.Product)
	g := persistence.NormalsFindFirstByYearAndLocation(request.BuildLocation())
	var returnGdds models.GddResponse
	if product == enums.ProductType.CORN {
		returnGdds = models.GddResponse{
			Product:          product.Name,
			NearestLatitude:  g.Location.Coordinates[1],
			NearestLongitude: g.Location.Coordinates[0],
			GddValues:        CalculateNormalGddValues(g.CornBase, product, request.Accumulate),
		}
	} else {
		returnGdds = models.GddResponse{
			Product:          product.Name,
			NearestLatitude:  g.Location.Coordinates[1],
			NearestLongitude: g.Location.Coordinates[0],
			GddValues:        CalculateNormalGddValues(g.GddBase, product, request.Accumulate),
		}
	}
	return returnGdds
}