diff --git a/controllers/gdd_controller.go b/controllers/gdd_controller.go
index 4d209ff98a4d59ccf743226b9d9b4f943c7a41bb..d482652ef7de9dc792c12941332b3b472e3e330e 100644
--- a/controllers/gdd_controller.go
+++ b/controllers/gdd_controller.go
@@ -46,6 +46,6 @@ func GetDailyGdd(c *fiber.Ctx) error {
// @Param accumulate query boolean true "Accumulate gdd values"
// @Router /gdd/normals [get]
func GetNormalGdd(c *fiber.Ctx) error {
- request := models.BuildYearlessGddRequest(c)
+ request := models.BuildGddRequest(c)
return c.Status(fiber.StatusOK).JSON(services.GetNormalValues(request))
}
diff --git a/controllers/nomads_controller.go b/controllers/nomads_controller.go
index c9f83002b3da0b64e259ffe8e118369500d4fc04..e79592543d4d4d5684a9580feb3f3e8213a093f4 100644
--- a/controllers/nomads_controller.go
+++ b/controllers/nomads_controller.go
@@ -23,7 +23,7 @@ import (
// @Param accumulate query boolean true "Accumulate gdd values"
// @Router /gdd/gefs [get]
func GetGefsGDD(c *fiber.Ctx) error {
- request := models.BuildYearlessGddRequest(c)
+ request := models.BuildGddRequest(c)
return c.Status(fiber.StatusOK).JSON(services.GetGefsGddValues(request))
}
@@ -41,7 +41,7 @@ func GetGefsGDD(c *fiber.Ctx) error {
// @Param accumulate query boolean true "Accumulate gdd values"
// @Router /gdd/cfs [get]
func GetCfsGDD(c *fiber.Ctx) error {
- request := models.BuildYearlessGddRequest(c)
+ request := models.BuildGddRequest(c)
return c.Status(fiber.StatusOK).JSON(services.GetCfsGddValues(request))
}
diff --git a/models/gdd.go b/models/gdd.go
index 6bd4cc7127fe06a8a3c86650f2b67c1f1563988d..6359241b72cd7dffdbd5b556b61ddd4d14b6227f 100644
--- a/models/gdd.go
+++ b/models/gdd.go
@@ -6,6 +6,7 @@ import (
"gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/config"
"gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence/entities"
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/utils"
validation "github.com/go-ozzo/ozzo-validation"
"github.com/gofiber/fiber/v2"
@@ -21,7 +22,6 @@ type GddResponse struct {
}
type GddRequest struct {
- Year int `json:"year"`
Product string `json:"product"`
Latitude float64 `json:"latitude"`
Longitude float64 `json:"longitude"`
@@ -31,7 +31,7 @@ type GddRequest struct {
func (r GddRequest) Validate() error {
return validation.ValidateStruct(&r,
- validation.Field(&r.Year, validation.Required, validation.Min(1981), validation.Max(time.Now().Year())),
+ // validation.Field(&r.Year, validation.Required, validation.Min(1981), validation.Max(time.Now().Year())),
validation.Field(&r.Product, validation.Required, validation.Length(1, 100)),
validation.Field(&r.Latitude, validation.Required, validation.Min(-90.0), validation.Max(90.0)),
validation.Field(&r.Longitude, validation.Required, validation.Min(-180.0), validation.Max(180.0)),
@@ -49,31 +49,32 @@ func (r GddRequest) ValidateNoYear() error {
var BuildGddRequest = func(c *fiber.Ctx) GddRequest {
year, errYear := strconv.Atoi(c.Query("year", strconv.Itoa(time.Now().Year())))
product := c.Query("product")
- pd := c.Query("plantingDate")
+ pd := c.Query("plantingDate", utils.GetFirstOfTheYear().Format(time.RFC3339))
latitude, errLat := strconv.ParseFloat(c.Query("latitude"), 64)
longitude, errLon := strconv.ParseFloat(c.Query("longitude"), 64)
accumulate, errBool := strconv.ParseBool(c.Query("accumulate", "false"))
plantingDate, errDate := time.Parse(time.RFC3339, pd)
- if errLat != nil || errLon != nil || errBool != nil {
+ if errYear != nil || errLat != nil || errLon != nil || errBool != nil {
panic(config.BAD_REQUEST)
}
- if errYear != nil && errDate != nil {
- panic(errors.NewBadRequest(nil).PutDetail("reason", "no date or year provided"))
- }
-
- // date is provided but year isnt
- if errYear != nil && errDate == nil {
- year = plantingDate.Year()
+ if errDate != nil {
+ panic(errors.NewBadRequest(nil).PutDetail("reason", "no planting date provided"))
}
if errDate != nil && pd != "" {
panic(errors.NewBadRequest(nil).PutDetail("reason", "date must be ISO8601 or RFC3339 format"))
}
+ // provided an override year
+ // used mostly for doing analog years where we dont provide a date
+ // if the years are different and the planting date year is this year, we override
+ if year != plantingDate.Year() && plantingDate.Year() == time.Now().Year() {
+ plantingDate = utils.GetFirstOfTheYearForYear(year)
+ }
+
rNew := GddRequest{
- Year: year,
Product: product,
Latitude: latitude,
Longitude: longitude,
diff --git a/services/data_download_service.go b/services/data_download_service.go
index 6280512bfec1203431c4b3029b96d40f68989bfa..791c1250ff2ce34eee9254232054208ee014b1b3 100644
--- a/services/data_download_service.go
+++ b/services/data_download_service.go
@@ -1,467 +1,468 @@
-package services
-
-import (
- "encoding/csv"
- "fmt"
- "io/ioutil"
- "log"
- "math"
- "os"
- "strconv"
- "strings"
- "time"
-
- "github.com/tgs266/dawn-go-common/common"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/config"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models/enums"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence/entities"
-
- "github.com/gofiber/fiber/v2"
- "github.com/google/uuid"
-)
-
-type CSVData struct {
- Date []time.Time
- Analog []float64
- Cfs []float64
- CfsLower []float64
- CfsUpper []float64
- Comparison []float64
- FirstFreezing []int
- LastFreezing []int
- GEFS []float64
- Maximum []float64
- Minimum []float64
- Normals []float64
- Primary []float64
-}
-
-func fillKeys(request models.CSVRequest) []string {
- keys := []string{}
-
- keys = append(keys, "Date")
- if request.Analog {
- keys = append(keys, "Analog Year GDD")
- }
- if request.Cfs || request.CfsLower || request.CfsUpper {
- keys = append(keys, "CFS GDD")
- keys = append(keys, "CFS Lower Boundary GDD")
- keys = append(keys, "CFS Upper Boundary GDD")
- }
- if request.Comparison {
- keys = append(keys, "Comparison Year GDD ("+strconv.Itoa(request.ComparisonYear)+")")
- }
- if request.FirstFreezing || request.LastFreezing {
- keys = append(keys, "First Freezing Date Counts ("+strconv.Itoa(request.Temperature)+" Degrees F)")
- keys = append(keys, "Last Freezing Date Counts ("+strconv.Itoa(request.Temperature)+" Degrees F)")
- }
- if request.Gefs {
- keys = append(keys, "GEFS GDD")
- }
- if request.Maximum {
- keys = append(keys, "Confidence Interval Upper Boundary")
- }
- if request.Minimum {
- keys = append(keys, "Confidence Interval Lower Boundary")
- }
- if request.Normals {
- keys = append(keys, "Thirty Year Normal GDD")
- }
- if request.Primary {
- keys = append(keys, "Primary GDD ("+strconv.Itoa(request.Year)+")")
- }
- return keys
-}
-
-func timeToString(timeValue time.Time) string {
- day := timeValue.Day()
- month := int(timeValue.Month())
- timeString := fmt.Sprintf("%02d", month) + "-" + fmt.Sprintf("%02d", day)
- return timeString
-}
-
-func fillDates() []time.Time {
- dates := []time.Time{}
- date := time.Date(1981, time.January, 1, 0, 0, 0, 0, time.UTC)
-
- for i := 0; i < 365; i++ {
- dates = append(dates, date)
- date = date.Add(time.Duration(24) * time.Hour)
- }
-
- return dates
-}
-
-func getPrimary(c common.DawnCtx, request models.CSVRequest, dates []time.Time) []float64 {
- gddRequest := models.GddRequest{
- Year: request.Year,
- Product: request.Product,
- Latitude: request.Latitude,
- Longitude: request.Longitude,
- Accumulate: true,
- }
-
- gddValues := GetGddValues(c, gddRequest).GddValues
- for len(gddValues) < 365 {
- gddValues = append(gddValues, math.NaN())
- }
- return gddValues
-}
-
-func getNormals(request models.CSVRequest, dates []time.Time) []float64 {
- gddRequest := models.GddRequest{
- Year: request.Year,
- Product: request.Product,
- Latitude: request.Latitude,
- Longitude: request.Longitude,
- Accumulate: true,
- }
-
- gddValues := GetNormalValues(gddRequest).GddValues
- for len(gddValues) < 365 {
- gddValues = append(gddValues, math.NaN())
- }
- return gddValues
-}
-
-func getAnalogYear(c *fiber.Ctx, request models.CSVRequest, dates []time.Time) []float64 {
-
- location := entities.Location{
- Type: "Point",
- Coordinates: []float64{request.Longitude, request.Latitude},
- }
-
- analogYear := persistence.FindAnalogYear(location).AnalogYear
-
- gddRequest := models.GddRequest{
- Year: analogYear,
- Product: request.Product,
- Latitude: request.Latitude,
- Longitude: request.Longitude,
- Accumulate: true,
- }
-
- gddValues := GetGddValues(common.BuildCtx(c), gddRequest).GddValues
- for len(gddValues) < 365 {
- gddValues = append(gddValues, math.NaN())
- }
- return gddValues
-}
-
-func _parseDate(date string) time.Time {
- const layout = "2006-Jan-02"
- newDate, e := time.Parse(layout, date)
- if e != nil {
- panic(config.DATE_PARSE_FAILURE.AddLogDetails(e.Error()))
- }
- return newDate
-}
-
-func parseDate(date string, year int) time.Time {
-
- split := strings.Split(date, "-")
- yearStr := strconv.Itoa(year)
- day := split[1]
- switch split[0] {
- case "01":
- return _parseDate(yearStr + "-Jan-" + day)
- case "02":
- return _parseDate(yearStr + "-Feb-" + day)
- case "03":
- return _parseDate(yearStr + "-Mar-" + day)
- case "04":
- return _parseDate(yearStr + "-Apr-" + day)
- case "05":
- return _parseDate(yearStr + "-May-" + day)
- case "06":
- return _parseDate(yearStr + "-Jun-" + day)
- case "07":
- return _parseDate(yearStr + "-Jul-" + day)
- case "08":
- return _parseDate(yearStr + "-Aug-" + day)
- case "09":
- return _parseDate(yearStr + "-Sep-" + day)
- case "10":
- return _parseDate(yearStr + "-Oct-" + day)
- case "11":
- return _parseDate(yearStr + "-Nov-" + day)
- case "12":
- return _parseDate(yearStr + "-Dec-" + day)
- }
- panic(config.DATE_PARSE_FAILURE.AddLogDetails("Failed converting " + date + " to proper format."))
-}
-
-func getFreezingDates(request models.CSVRequest, dates []time.Time) [][]int {
-
- freezingRequest := models.FreezingDateRequest{
- Latitude: request.Latitude,
- Longitude: request.Longitude,
- FreezingTemp: request.Temperature,
- }
-
- response := GetFreezingDate(freezingRequest)
-
- firstFreezingDates := make(map[time.Time]int)
- lastFreezingDates := make(map[time.Time]int)
- for k, v := range response.LastDateCounts {
- // for i := 0; i < v.Count; i++ {
- date := parseDate(k, 1981)
- lastFreezingDates[date] = v.Count
- // }
- }
- for k, v := range response.FirstDateCounts {
- // for i := 0; i < v.Count; i++ {
- date := parseDate(k, 1981)
- firstFreezingDates[date] = v.Count
- // }
- }
-
- date := time.Date(1981, time.January, 1, 0, 0, 0, 0, time.UTC)
- lastFreezingValues := []int{}
- firstFreezingValues := []int{}
- for i := 0; i < 366; i++ {
- if val, ok := lastFreezingDates[date]; ok {
- lastFreezingValues = append(lastFreezingValues, val)
- firstFreezingValues = append(firstFreezingValues, int(math.NaN()))
- } else if val, ok := firstFreezingDates[date]; ok {
- firstFreezingValues = append(firstFreezingValues, val)
- lastFreezingValues = append(lastFreezingValues, int(math.NaN()))
- } else {
- firstFreezingValues = append(firstFreezingValues, int(math.NaN()))
- lastFreezingValues = append(lastFreezingValues, int(math.NaN()))
- }
- date = date.Add(time.Duration(24) * time.Hour)
- }
- return [][]int{firstFreezingValues, lastFreezingValues}
-}
-
-func getComparisonYear(c common.DawnCtx, request models.CSVRequest, dates []time.Time) []float64 {
- gddRequest := models.GddRequest{
- Year: request.ComparisonYear,
- Product: request.Product,
- Latitude: request.Latitude,
- Longitude: request.Longitude,
- Accumulate: true,
- }
-
- gddValues := GetGddValues(c, gddRequest).GddValues
- for len(gddValues) < 365 {
- gddValues = append(gddValues, math.NaN())
- }
- return gddValues
-}
-
-func getConfidenceInterval(request models.CSVRequest, dates []time.Time) [][]float64 {
-
- ciRequest := models.ConfidenceIntervalRequest{
- Interval: request.Range,
- Product: enums.GetProductFromString(request.Product),
- Latitude: request.Latitude,
- Longitude: request.Longitude,
- }
-
- response := GetConfidenceInterval(ciRequest)
-
- return [][]float64{response.LowerBound, response.UpperBound}
-}
-
-func getCfsData(request models.CSVRequest, dates []time.Time) [][]float64 {
-
- gddRequest := models.GddRequest{
- Year: request.Year,
- Product: request.Product,
- Latitude: request.Latitude,
- Longitude: request.Longitude,
- Accumulate: true,
- }
-
- response := GetCfsGddValues(gddRequest)
- fullGddValues := []float64{}
- fullLowerBound := []float64{}
- fullUpperBound := []float64{}
- in := false
- after := false
- c := 0
- date := time.Date(response.FirstDate.Year(), time.January, 1, 0, 0, 0, 0, time.UTC)
- for i := 0; i < 366; i++ {
- if response.FirstDate.After(date) {
- fullGddValues = append(fullGddValues, math.NaN())
- fullLowerBound = append(fullLowerBound, math.NaN())
- fullUpperBound = append(fullUpperBound, math.NaN())
- } else {
- if in || response.FirstDate == date {
- if c >= len(response.GddValues) {
- in = false
- after = true
- } else {
- in = true
- fullGddValues = append(fullGddValues, response.GddValues[c])
- fullLowerBound = append(fullLowerBound, response.LowerBound[c])
- fullUpperBound = append(fullUpperBound, response.UpperBound[c])
- c += 1
- }
- } else if after {
- fullGddValues = append(fullGddValues, math.NaN())
- fullLowerBound = append(fullLowerBound, math.NaN())
- fullUpperBound = append(fullUpperBound, math.NaN())
- }
- }
- date = date.Add(time.Duration(24) * time.Hour)
-
- }
- return [][]float64{fullGddValues, fullLowerBound, fullUpperBound}
-}
-
-func getGefsData(request models.CSVRequest, dates []time.Time) []float64 {
-
- gddRequest := models.GddRequest{
- Year: request.Year,
- Product: request.Product,
- Latitude: request.Latitude,
- Longitude: request.Longitude,
- Accumulate: true,
- }
-
- response := GetGefsGddValues(gddRequest)
- fullGddValues := []float64{}
- in := false
- after := false
- c := 0
- date := time.Date(response.FirstDate.Year(), time.January, 1, 0, 0, 0, 0, time.UTC)
- for i := 0; i < 366; i++ {
- if response.FirstDate.After(date) {
- fullGddValues = append(fullGddValues, math.NaN())
- } else {
- if in || response.FirstDate == date {
- if c >= len(response.GddValues) {
- in = false
- after = true
- } else {
- in = true
- fullGddValues = append(fullGddValues, response.GddValues[c])
- c += 1
- }
- } else if after {
- fullGddValues = append(fullGddValues, math.NaN())
- }
- }
- date = date.Add(time.Duration(24) * time.Hour)
-
- }
- return fullGddValues
-}
-
-func pullData(c common.DawnCtx, request models.CSVRequest) CSVData {
- returnData := CSVData{}
- dates := fillDates()
- returnData.Date = dates
-
- if request.Analog {
- returnData.Analog = getAnalogYear(c.FiberCtx, request, dates)
- }
- if request.Cfs || request.CfsLower || request.CfsUpper {
- t := getCfsData(request, dates)
- returnData.Cfs = t[0]
- returnData.CfsLower = t[1]
- returnData.CfsUpper = t[2]
- }
- if request.Comparison {
- returnData.Comparison = getComparisonYear(c, request, dates)
- }
- if request.FirstFreezing || request.LastFreezing {
- t := getFreezingDates(request, dates)
- returnData.FirstFreezing = t[0]
- returnData.LastFreezing = t[1]
- }
- if request.Gefs {
- returnData.GEFS = getGefsData(request, dates)
- }
- if request.Maximum || request.Minimum {
- ci := getConfidenceInterval(request, dates)
- returnData.Maximum = ci[1]
- returnData.Minimum = ci[0]
- }
- if request.Normals {
- returnData.Normals = getNormals(request, dates)
- }
- if request.Primary {
- returnData.Primary = getPrimary(c, request, dates)
- }
-
- return returnData
-}
-
-func createRecords(keys []string, data CSVData) [][]string {
- records := [][]string{keys}
- for i := 1; i < 366; i++ {
- temp := []string{timeToString(data.Date[i-1])}
- if len(data.Analog) != 0 {
- temp = append(temp, fmt.Sprintf("%f", data.Analog[i-1]))
- }
- if len(data.Cfs) != 0 {
- temp = append(temp, fmt.Sprintf("%f", data.Cfs[i-1]))
- temp = append(temp, fmt.Sprintf("%f", data.CfsLower[i-1]))
- temp = append(temp, fmt.Sprintf("%f", data.CfsUpper[i-1]))
- }
- if len(data.Comparison) != 0 {
- temp = append(temp, fmt.Sprintf("%f", data.Comparison[i-1]))
- }
- if len(data.FirstFreezing) != 0 {
- temp = append(temp, fmt.Sprintf("%d", data.FirstFreezing[i-1]))
- temp = append(temp, fmt.Sprintf("%d", data.LastFreezing[i-1]))
- }
- if len(data.GEFS) != 0 {
- temp = append(temp, fmt.Sprintf("%f", data.GEFS[i-1]))
- }
- if len(data.Maximum) != 0 {
- temp = append(temp, fmt.Sprintf("%f", data.Maximum[i-1]))
- temp = append(temp, fmt.Sprintf("%f", data.Minimum[i-1]))
- }
- if len(data.Normals) != 0 {
- temp = append(temp, fmt.Sprintf("%f", data.Normals[i-1]))
- }
- if len(data.Primary) != 0 {
- temp = append(temp, fmt.Sprintf("%f", data.Primary[i-1]))
- }
-
- records = append(records, temp)
- }
- return records
-}
-
-func GetDataDownload(c common.DawnCtx, request models.CSVRequest) string {
-
- fileId := uuid.New()
-
- f, err := os.Create(fileId.String() + ".csv")
-
- if err != nil {
- panic(config.FILE_CREATION_ERROR.AddLogDetails("Could not create file"))
- }
-
- w := csv.NewWriter(f)
-
- keys := fillKeys(request)
-
- data := pullData(c, request)
-
- records := createRecords(keys, data)
-
- for _, record := range records {
- if err := w.Write(record); err != nil {
- log.Fatalln("error writing record to file", err)
- }
- }
-
- w.Flush()
-
- fileText, err := ioutil.ReadFile(fileId.String() + ".csv")
- f.Close()
- e := os.Remove(fileId.String() + ".csv")
- if e != nil {
- log.Fatal(e)
- }
- return string(fileText)
-}
+package services
+
+import (
+ "encoding/csv"
+ "fmt"
+ "io/ioutil"
+ "log"
+ "math"
+ "os"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/tgs266/dawn-go-common/common"
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/config"
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models"
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models/enums"
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence"
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence/entities"
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/utils"
+
+ "github.com/gofiber/fiber/v2"
+ "github.com/google/uuid"
+)
+
+type CSVData struct {
+ Date []time.Time
+ Analog []float64
+ Cfs []float64
+ CfsLower []float64
+ CfsUpper []float64
+ Comparison []float64
+ FirstFreezing []int
+ LastFreezing []int
+ GEFS []float64
+ Maximum []float64
+ Minimum []float64
+ Normals []float64
+ Primary []float64
+}
+
+func fillKeys(request models.CSVRequest) []string {
+ keys := []string{}
+
+ keys = append(keys, "Date")
+ if request.Analog {
+ keys = append(keys, "Analog Year GDD")
+ }
+ if request.Cfs || request.CfsLower || request.CfsUpper {
+ keys = append(keys, "CFS GDD")
+ keys = append(keys, "CFS Lower Boundary GDD")
+ keys = append(keys, "CFS Upper Boundary GDD")
+ }
+ if request.Comparison {
+ keys = append(keys, "Comparison Year GDD ("+strconv.Itoa(request.ComparisonYear)+")")
+ }
+ if request.FirstFreezing || request.LastFreezing {
+ keys = append(keys, "First Freezing Date Counts ("+strconv.Itoa(request.Temperature)+" Degrees F)")
+ keys = append(keys, "Last Freezing Date Counts ("+strconv.Itoa(request.Temperature)+" Degrees F)")
+ }
+ if request.Gefs {
+ keys = append(keys, "GEFS GDD")
+ }
+ if request.Maximum {
+ keys = append(keys, "Confidence Interval Upper Boundary")
+ }
+ if request.Minimum {
+ keys = append(keys, "Confidence Interval Lower Boundary")
+ }
+ if request.Normals {
+ keys = append(keys, "Thirty Year Normal GDD")
+ }
+ if request.Primary {
+ keys = append(keys, "Primary GDD ("+strconv.Itoa(request.Year)+")")
+ }
+ return keys
+}
+
+func timeToString(timeValue time.Time) string {
+ day := timeValue.Day()
+ month := int(timeValue.Month())
+ timeString := fmt.Sprintf("%02d", month) + "-" + fmt.Sprintf("%02d", day)
+ return timeString
+}
+
+func fillDates() []time.Time {
+ dates := []time.Time{}
+ date := time.Date(1981, time.January, 1, 0, 0, 0, 0, time.UTC)
+
+ for i := 0; i < 365; i++ {
+ dates = append(dates, date)
+ date = date.Add(time.Duration(24) * time.Hour)
+ }
+
+ return dates
+}
+
+func getPrimary(c common.DawnCtx, request models.CSVRequest, dates []time.Time) []float64 {
+ gddRequest := models.GddRequest{
+ PlantingDate: utils.GetFirstOfTheYearForYear(request.Year),
+ Product: request.Product,
+ Latitude: request.Latitude,
+ Longitude: request.Longitude,
+ Accumulate: true,
+ }
+
+ gddValues := GetGddValues(c, gddRequest).GddValues
+ for len(gddValues) < 365 {
+ gddValues = append(gddValues, math.NaN())
+ }
+ return gddValues
+}
+
+func getNormals(request models.CSVRequest, dates []time.Time) []float64 {
+ gddRequest := models.GddRequest{
+ PlantingDate: utils.GetFirstOfTheYearForYear(request.Year),
+ Product: request.Product,
+ Latitude: request.Latitude,
+ Longitude: request.Longitude,
+ Accumulate: true,
+ }
+
+ gddValues := GetNormalValues(gddRequest).GddValues
+ for len(gddValues) < 365 {
+ gddValues = append(gddValues, math.NaN())
+ }
+ return gddValues
+}
+
+func getAnalogYear(c *fiber.Ctx, request models.CSVRequest, dates []time.Time) []float64 {
+
+ location := entities.Location{
+ Type: "Point",
+ Coordinates: []float64{request.Longitude, request.Latitude},
+ }
+
+ analogYear := persistence.FindAnalogYear(location).AnalogYear
+
+ gddRequest := models.GddRequest{
+ PlantingDate: utils.GetFirstOfTheYearForYear(analogYear),
+ Product: request.Product,
+ Latitude: request.Latitude,
+ Longitude: request.Longitude,
+ Accumulate: true,
+ }
+
+ gddValues := GetGddValues(common.BuildCtx(c), gddRequest).GddValues
+ for len(gddValues) < 365 {
+ gddValues = append(gddValues, math.NaN())
+ }
+ return gddValues
+}
+
+func _parseDate(date string) time.Time {
+ const layout = "2006-Jan-02"
+ newDate, e := time.Parse(layout, date)
+ if e != nil {
+ panic(config.DATE_PARSE_FAILURE.AddLogDetails(e.Error()))
+ }
+ return newDate
+}
+
+func parseDate(date string, year int) time.Time {
+
+ split := strings.Split(date, "-")
+ yearStr := strconv.Itoa(year)
+ day := split[1]
+ switch split[0] {
+ case "01":
+ return _parseDate(yearStr + "-Jan-" + day)
+ case "02":
+ return _parseDate(yearStr + "-Feb-" + day)
+ case "03":
+ return _parseDate(yearStr + "-Mar-" + day)
+ case "04":
+ return _parseDate(yearStr + "-Apr-" + day)
+ case "05":
+ return _parseDate(yearStr + "-May-" + day)
+ case "06":
+ return _parseDate(yearStr + "-Jun-" + day)
+ case "07":
+ return _parseDate(yearStr + "-Jul-" + day)
+ case "08":
+ return _parseDate(yearStr + "-Aug-" + day)
+ case "09":
+ return _parseDate(yearStr + "-Sep-" + day)
+ case "10":
+ return _parseDate(yearStr + "-Oct-" + day)
+ case "11":
+ return _parseDate(yearStr + "-Nov-" + day)
+ case "12":
+ return _parseDate(yearStr + "-Dec-" + day)
+ }
+ panic(config.DATE_PARSE_FAILURE.AddLogDetails("Failed converting " + date + " to proper format."))
+}
+
+func getFreezingDates(request models.CSVRequest, dates []time.Time) [][]int {
+
+ freezingRequest := models.FreezingDateRequest{
+ Latitude: request.Latitude,
+ Longitude: request.Longitude,
+ FreezingTemp: request.Temperature,
+ }
+
+ response := GetFreezingDate(freezingRequest)
+
+ firstFreezingDates := make(map[time.Time]int)
+ lastFreezingDates := make(map[time.Time]int)
+ for k, v := range response.LastDateCounts {
+ // for i := 0; i < v.Count; i++ {
+ date := parseDate(k, 1981)
+ lastFreezingDates[date] = v.Count
+ // }
+ }
+ for k, v := range response.FirstDateCounts {
+ // for i := 0; i < v.Count; i++ {
+ date := parseDate(k, 1981)
+ firstFreezingDates[date] = v.Count
+ // }
+ }
+
+ date := time.Date(1981, time.January, 1, 0, 0, 0, 0, time.UTC)
+ lastFreezingValues := []int{}
+ firstFreezingValues := []int{}
+ for i := 0; i < 366; i++ {
+ if val, ok := lastFreezingDates[date]; ok {
+ lastFreezingValues = append(lastFreezingValues, val)
+ firstFreezingValues = append(firstFreezingValues, int(math.NaN()))
+ } else if val, ok := firstFreezingDates[date]; ok {
+ firstFreezingValues = append(firstFreezingValues, val)
+ lastFreezingValues = append(lastFreezingValues, int(math.NaN()))
+ } else {
+ firstFreezingValues = append(firstFreezingValues, int(math.NaN()))
+ lastFreezingValues = append(lastFreezingValues, int(math.NaN()))
+ }
+ date = date.Add(time.Duration(24) * time.Hour)
+ }
+ return [][]int{firstFreezingValues, lastFreezingValues}
+}
+
+func getComparisonYear(c common.DawnCtx, request models.CSVRequest, dates []time.Time) []float64 {
+ gddRequest := models.GddRequest{
+ PlantingDate: utils.GetFirstOfTheYearForYear(request.ComparisonYear),
+ Product: request.Product,
+ Latitude: request.Latitude,
+ Longitude: request.Longitude,
+ Accumulate: true,
+ }
+
+ gddValues := GetGddValues(c, gddRequest).GddValues
+ for len(gddValues) < 365 {
+ gddValues = append(gddValues, math.NaN())
+ }
+ return gddValues
+}
+
+func getConfidenceInterval(request models.CSVRequest, dates []time.Time) [][]float64 {
+
+ ciRequest := models.ConfidenceIntervalRequest{
+ Interval: request.Range,
+ Product: enums.GetProductFromString(request.Product),
+ Latitude: request.Latitude,
+ Longitude: request.Longitude,
+ }
+
+ response := GetConfidenceInterval(ciRequest)
+
+ return [][]float64{response.LowerBound, response.UpperBound}
+}
+
+func getCfsData(request models.CSVRequest, dates []time.Time) [][]float64 {
+
+ gddRequest := models.GddRequest{
+ PlantingDate: utils.GetFirstOfTheYearForYear(request.Year),
+ Product: request.Product,
+ Latitude: request.Latitude,
+ Longitude: request.Longitude,
+ Accumulate: true,
+ }
+
+ response := GetCfsGddValues(gddRequest)
+ fullGddValues := []float64{}
+ fullLowerBound := []float64{}
+ fullUpperBound := []float64{}
+ in := false
+ after := false
+ c := 0
+ date := time.Date(response.FirstDate.Year(), time.January, 1, 0, 0, 0, 0, time.UTC)
+ for i := 0; i < 366; i++ {
+ if response.FirstDate.After(date) {
+ fullGddValues = append(fullGddValues, math.NaN())
+ fullLowerBound = append(fullLowerBound, math.NaN())
+ fullUpperBound = append(fullUpperBound, math.NaN())
+ } else {
+ if in || response.FirstDate == date {
+ if c >= len(response.GddValues) {
+ in = false
+ after = true
+ } else {
+ in = true
+ fullGddValues = append(fullGddValues, response.GddValues[c])
+ fullLowerBound = append(fullLowerBound, response.LowerBound[c])
+ fullUpperBound = append(fullUpperBound, response.UpperBound[c])
+ c += 1
+ }
+ } else if after {
+ fullGddValues = append(fullGddValues, math.NaN())
+ fullLowerBound = append(fullLowerBound, math.NaN())
+ fullUpperBound = append(fullUpperBound, math.NaN())
+ }
+ }
+ date = date.Add(time.Duration(24) * time.Hour)
+
+ }
+ return [][]float64{fullGddValues, fullLowerBound, fullUpperBound}
+}
+
+func getGefsData(request models.CSVRequest, dates []time.Time) []float64 {
+
+ gddRequest := models.GddRequest{
+ PlantingDate: utils.GetFirstOfTheYearForYear(request.Year),
+ Product: request.Product,
+ Latitude: request.Latitude,
+ Longitude: request.Longitude,
+ Accumulate: true,
+ }
+
+ response := GetGefsGddValues(gddRequest)
+ fullGddValues := []float64{}
+ in := false
+ after := false
+ c := 0
+ date := time.Date(response.FirstDate.Year(), time.January, 1, 0, 0, 0, 0, time.UTC)
+ for i := 0; i < 366; i++ {
+ if response.FirstDate.After(date) {
+ fullGddValues = append(fullGddValues, math.NaN())
+ } else {
+ if in || response.FirstDate == date {
+ if c >= len(response.GddValues) {
+ in = false
+ after = true
+ } else {
+ in = true
+ fullGddValues = append(fullGddValues, response.GddValues[c])
+ c += 1
+ }
+ } else if after {
+ fullGddValues = append(fullGddValues, math.NaN())
+ }
+ }
+ date = date.Add(time.Duration(24) * time.Hour)
+
+ }
+ return fullGddValues
+}
+
+func pullData(c common.DawnCtx, request models.CSVRequest) CSVData {
+ returnData := CSVData{}
+ dates := fillDates()
+ returnData.Date = dates
+
+ if request.Analog {
+ returnData.Analog = getAnalogYear(c.FiberCtx, request, dates)
+ }
+ if request.Cfs || request.CfsLower || request.CfsUpper {
+ t := getCfsData(request, dates)
+ returnData.Cfs = t[0]
+ returnData.CfsLower = t[1]
+ returnData.CfsUpper = t[2]
+ }
+ if request.Comparison {
+ returnData.Comparison = getComparisonYear(c, request, dates)
+ }
+ if request.FirstFreezing || request.LastFreezing {
+ t := getFreezingDates(request, dates)
+ returnData.FirstFreezing = t[0]
+ returnData.LastFreezing = t[1]
+ }
+ if request.Gefs {
+ returnData.GEFS = getGefsData(request, dates)
+ }
+ if request.Maximum || request.Minimum {
+ ci := getConfidenceInterval(request, dates)
+ returnData.Maximum = ci[1]
+ returnData.Minimum = ci[0]
+ }
+ if request.Normals {
+ returnData.Normals = getNormals(request, dates)
+ }
+ if request.Primary {
+ returnData.Primary = getPrimary(c, request, dates)
+ }
+
+ return returnData
+}
+
+func createRecords(keys []string, data CSVData) [][]string {
+ records := [][]string{keys}
+ for i := 1; i < 366; i++ {
+ temp := []string{timeToString(data.Date[i-1])}
+ if len(data.Analog) != 0 {
+ temp = append(temp, fmt.Sprintf("%f", data.Analog[i-1]))
+ }
+ if len(data.Cfs) != 0 {
+ temp = append(temp, fmt.Sprintf("%f", data.Cfs[i-1]))
+ temp = append(temp, fmt.Sprintf("%f", data.CfsLower[i-1]))
+ temp = append(temp, fmt.Sprintf("%f", data.CfsUpper[i-1]))
+ }
+ if len(data.Comparison) != 0 {
+ temp = append(temp, fmt.Sprintf("%f", data.Comparison[i-1]))
+ }
+ if len(data.FirstFreezing) != 0 {
+ temp = append(temp, fmt.Sprintf("%d", data.FirstFreezing[i-1]))
+ temp = append(temp, fmt.Sprintf("%d", data.LastFreezing[i-1]))
+ }
+ if len(data.GEFS) != 0 {
+ temp = append(temp, fmt.Sprintf("%f", data.GEFS[i-1]))
+ }
+ if len(data.Maximum) != 0 {
+ temp = append(temp, fmt.Sprintf("%f", data.Maximum[i-1]))
+ temp = append(temp, fmt.Sprintf("%f", data.Minimum[i-1]))
+ }
+ if len(data.Normals) != 0 {
+ temp = append(temp, fmt.Sprintf("%f", data.Normals[i-1]))
+ }
+ if len(data.Primary) != 0 {
+ temp = append(temp, fmt.Sprintf("%f", data.Primary[i-1]))
+ }
+
+ records = append(records, temp)
+ }
+ return records
+}
+
+func GetDataDownload(c common.DawnCtx, request models.CSVRequest) string {
+
+ fileId := uuid.New()
+
+ f, err := os.Create(fileId.String() + ".csv")
+
+ if err != nil {
+ panic(config.FILE_CREATION_ERROR.AddLogDetails("Could not create file"))
+ }
+
+ w := csv.NewWriter(f)
+
+ keys := fillKeys(request)
+
+ data := pullData(c, request)
+
+ records := createRecords(keys, data)
+
+ for _, record := range records {
+ if err := w.Write(record); err != nil {
+ log.Fatalln("error writing record to file", err)
+ }
+ }
+
+ w.Flush()
+
+ fileText, err := ioutil.ReadFile(fileId.String() + ".csv")
+ f.Close()
+ e := os.Remove(fileId.String() + ".csv")
+ if e != nil {
+ log.Fatal(e)
+ }
+ return string(fileText)
+}
diff --git a/services/forecast_service.go b/services/forecast_service.go
index 77448c7dad25334a2ad63f292a268b2b698fd55e..c59b95b86e7ecf030e69865f509e31ccee8a3c3e 100644
--- a/services/forecast_service.go
+++ b/services/forecast_service.go
@@ -338,11 +338,11 @@ func asyncCollectGddsAndCfs(ctx common.DawnCtx, gddReq models.GddRequest) (model
*/
func CalculateStages(ctx common.DawnCtx, request models.StageRequest) map[string]*models.Bins {
gddReq := models.GddRequest{
- Year: request.PlantDate.Year(),
- Latitude: request.Latitude,
- Longitude: request.Longitude,
- Accumulate: false,
- Product: "CORN",
+ PlantingDate: request.PlantDate,
+ Latitude: request.Latitude,
+ Longitude: request.Longitude,
+ Accumulate: false,
+ Product: "CORN",
}
stageMatches := models.BuildStageMatches(request.Mode, request.Value)
diff --git a/services/gdd_service.go b/services/gdd_service.go
index c6adc8d4a5a7c751ec3ba557f584dae14ccd4714..3b73b2f62895f17889cd7a7066dd53229712bd1a 100644
--- a/services/gdd_service.go
+++ b/services/gdd_service.go
@@ -12,37 +12,16 @@ import (
"gonum.org/v1/gonum/stat"
)
-func GetFullYearGddValues(ctx common.DawnCtx, request models.GddRequest) models.GddResponse {
- product := enums.GetProductFromString(request.Product)
- var gdds entities.Gdd
- if request.Year == time.Now().Year() {
- gdds = persistence.CurrentGddFindFirstByYearAndLocation(ctx, request.BuildLocation())
- gdds2 := persistence.CfsFindAllByLocation(request.BuildLocation())
- gdds.MaxTemps = append(gdds.MaxTemps, gdds2.MaxTemps...)
- gdds.MinTemps = append(gdds.MinTemps, gdds2.MinTemps...)
- } else {
- gdds = persistence.GddFindFirstByYearAndLocation(request.Year, request.BuildLocation())
- }
- returnGdds := models.GddResponse{
- Product: product.Name,
- ClosestLatitude: gdds.Location.Coordinates[1],
- ClosestLongitude: gdds.Location.Coordinates[0],
- GddValues: utils.CalculateGddValues(gdds.MinTemps, gdds.MaxTemps, product, request.Accumulate),
- LastDate: gdds.LastDate.Time(),
- }
- return returnGdds
-}
-
func GetGddValues(ctx common.DawnCtx, request models.GddRequest) models.GddResponse {
product := enums.GetProductFromString(request.Product)
var gdds entities.Gdd
- if request.Year == time.Now().Year() {
+ if request.PlantingDate.Year() == time.Now().Year() {
gdds = persistence.CurrentGddFindFirstByYearAndLocation(ctx, request.BuildLocation())
} else {
- gdds = persistence.GddFindFirstByYearAndLocation(request.Year, request.BuildLocation())
+ gdds = persistence.GddFindFirstByYearAndLocation(request.PlantingDate.Year(), request.BuildLocation())
}
- if !request.PlantingDate.IsZero() && request.Year >= time.Now().Year() {
+ if request.PlantingDate.Year() >= time.Now().Year() {
pdInt := request.PlantingDate.YearDay() - 1
gdds.MaxTemps = gdds.MaxTemps[pdInt:]
gdds.MinTemps = gdds.MinTemps[pdInt:]
diff --git a/services/nomads_service.go b/services/nomads_service.go
index b9e29af10c4cc0aae5c0f2bd795d936288e36ecc..2aa0a7448b6448fe8b58073204baf012ef579026 100644
--- a/services/nomads_service.go
+++ b/services/nomads_service.go
@@ -1,96 +1,118 @@
-package services
-
-import (
- "math"
-
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models/enums"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/utils"
- "gonum.org/v1/gonum/stat"
-)
-
-func GetGefsGddValues(request models.GddRequest) models.GefsGddResponse {
- product := enums.GetProductFromString(request.Product)
- location := request.BuildLocation()
- g := persistence.GefsFindAllByLocation(location)
- var returnGdds models.GefsGddResponse
-
- var gdds []float64
- var lowerBound []float64
- var upperBound []float64
-
- for i := 0; i < 10; i++ {
- temp := g[i]
- variance := (temp.VarMin + temp.VarMax)
- variance *= math.Pow(0.5, 2)
- std := math.Pow(variance, 0.5)
-
- value := utils.CalculateSingleGdd(temp.MinTemp, temp.MaxTemp, product)
-
- lowerBoundValue := (value - (std / (math.Pow(3, 0.5)) * 1.960))
- upperBoundValue := (value + (std / (math.Pow(3, 0.5)) * 1.960))
-
- lowerBoundValue = utils.ClipMinFloat(lowerBoundValue, 0.0)
- upperBoundValue = utils.ClipMinFloat(upperBoundValue, 0.0)
-
- if request.Accumulate && i > 0 {
- value += gdds[len(gdds)-1]
- lowerBoundValue += lowerBound[len(gdds)-1]
- upperBoundValue += upperBound[len(gdds)-1]
- }
- gdds = append(gdds, value)
- lowerBound = append(lowerBound, lowerBoundValue)
- upperBound = append(upperBound, upperBoundValue)
- }
-
- returnGdds = models.GefsGddResponse{
- Product: product.Name,
- ClosestLatitude: location.Coordinates[1],
- ClosestLongitude: location.Coordinates[0],
- GddValues: gdds,
- UpperBound: upperBound,
- LowerBound: lowerBound,
- FirstDate: g[0].Date.Time().UTC(),
- LastDate: g[9].Date.Time().UTC(),
- }
- return returnGdds
-}
-
-func GetCfsGddValues(request models.GddRequest) models.CfsGddResponse {
- location := request.BuildLocation()
- gs := persistence.CfsFindByLocation(location)
- product := enums.GetProductFromString(request.Product)
- var returnGdds models.CfsGddResponse
-
- var gdds []float64
- var lowerBound []float64
- var upperBound []float64
-
- rows := [][]float64{}
- for i := 0; i < len(gs[0].MinTemps); i++ {
- row := []float64{}
- for j := 0; j < len(gs); j++ {
- row = append(row, utils.CalculateSingleGdd(gs[j].MinTemps[i], gs[j].MaxTemps[i], product))
- if request.Accumulate && i > 0 {
- row[j] += rows[len(rows)-1][j]
- }
- }
- rows = append(rows, row)
- mean, std := stat.MeanStdDev(row, nil)
- gdds = append(gdds, mean)
- upperBound = append(upperBound, utils.ClipMinFloat(mean+std*1.645, 0))
- lowerBound = append(lowerBound, utils.ClipMinFloat(mean-std*1.645, 0))
- }
-
- returnGdds = models.CfsGddResponse{
- Product: product.Name,
- ClosestLatitude: location.Coordinates[1],
- ClosestLongitude: location.Coordinates[0],
- GddValues: gdds,
- LowerBound: lowerBound,
- UpperBound: upperBound,
- FirstDate: gs[0].Date.Time().UTC(),
- }
- return returnGdds
-}
+package services
+
+import (
+ "math"
+
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models"
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models/enums"
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence"
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/utils"
+ "gonum.org/v1/gonum/stat"
+)
+
+func GetGefsGddValues(request models.GddRequest) models.GefsGddResponse {
+ product := enums.GetProductFromString(request.Product)
+ location := request.BuildLocation()
+ g := persistence.GefsFindAllByLocation(location)
+ var returnGdds models.GefsGddResponse
+
+ gdds := []float64{}
+ lowerBound := []float64{}
+ upperBound := []float64{}
+
+ // get the int of the planting date. If the date is less than the first date, we do nothing
+ // otherwise, we adjust
+ // need to do before because of accumulations
+ sliceDateInt := utils.DaysSince(g[0].Date.Time(), request.PlantingDate)
+ fd := request.PlantingDate
+ if sliceDateInt < 0 {
+ sliceDateInt = 0
+ fd = g[0].Date.Time()
+ }
+
+ for i := sliceDateInt; i < 10; i++ {
+ temp := g[i]
+ variance := (temp.VarMin + temp.VarMax)
+ variance *= math.Pow(0.5, 2)
+ std := math.Pow(variance, 0.5)
+
+ value := utils.CalculateSingleGdd(temp.MinTemp, temp.MaxTemp, product)
+
+ lowerBoundValue := (value - (std / (math.Pow(3, 0.5)) * 1.960))
+ upperBoundValue := (value + (std / (math.Pow(3, 0.5)) * 1.960))
+
+ lowerBoundValue = utils.ClipMinFloat(lowerBoundValue, 0.0)
+ upperBoundValue = utils.ClipMinFloat(upperBoundValue, 0.0)
+
+ if request.Accumulate && i > sliceDateInt {
+ value += gdds[len(gdds)-1]
+ lowerBoundValue += lowerBound[len(gdds)-1]
+ upperBoundValue += upperBound[len(gdds)-1]
+ }
+ gdds = append(gdds, value)
+ lowerBound = append(lowerBound, lowerBoundValue)
+ upperBound = append(upperBound, upperBoundValue)
+ }
+
+ returnGdds = models.GefsGddResponse{
+ Product: product.Name,
+ ClosestLatitude: location.Coordinates[1],
+ ClosestLongitude: location.Coordinates[0],
+ GddValues: gdds,
+ UpperBound: upperBound,
+ LowerBound: lowerBound,
+ FirstDate: fd.UTC(),
+ LastDate: g[9].Date.Time().UTC(),
+ }
+ return returnGdds
+}
+
+func GetCfsGddValues(request models.GddRequest) models.CfsGddResponse {
+ location := request.BuildLocation()
+ gs := persistence.CfsFindByLocation(location)
+ product := enums.GetProductFromString(request.Product)
+ var returnGdds models.CfsGddResponse
+
+ gdds := []float64{}
+ lowerBound := []float64{}
+ upperBound := []float64{}
+
+ // get the int of the planting date. If the date is less than the first date, we do nothing
+ // otherwise, we adjust
+ // need to do before because of accumulations
+ sliceDateInt := utils.DaysSince(gs[0].Date.Time(), request.PlantingDate)
+ fd := request.PlantingDate
+ if sliceDateInt < 0 {
+ sliceDateInt = 0
+ fd = gs[0].Date.Time()
+ }
+
+ rows := [][]float64{}
+ for i := sliceDateInt; i < len(gs[0].MinTemps); i++ {
+ row := []float64{}
+
+ for j := 0; j < len(gs); j++ {
+ row = append(row, utils.CalculateSingleGdd(gs[j].MinTemps[i], gs[j].MaxTemps[i], product))
+ if request.Accumulate && i > sliceDateInt {
+ row[j] += rows[len(rows)-1][j]
+ }
+ }
+
+ rows = append(rows, row)
+ mean, std := stat.MeanStdDev(row, nil)
+ gdds = append(gdds, mean)
+ upperBound = append(upperBound, utils.ClipMinFloat(mean+std*1.645, 0))
+ lowerBound = append(lowerBound, utils.ClipMinFloat(mean-std*1.645, 0))
+ }
+
+ returnGdds = models.CfsGddResponse{
+ Product: product.Name,
+ ClosestLatitude: location.Coordinates[1],
+ ClosestLongitude: location.Coordinates[0],
+ GddValues: gdds,
+ LowerBound: lowerBound,
+ UpperBound: upperBound,
+ FirstDate: fd.UTC(),
+ }
+ return returnGdds
+}
diff --git a/services/nomads_service_test.go b/services/nomads_service_test.go
index dab4bb221227ed58d3d2bd86f1590508b4f9ca02..5d5b0c9cf37fca82ca3e21ac637a2cb10b16ec8b 100644
--- a/services/nomads_service_test.go
+++ b/services/nomads_service_test.go
@@ -1,162 +1,156 @@
-package services
-
-import (
- "testing"
-
- "github.com/stretchr/testify/assert"
- DawnTest "github.com/tgs266/dawn-go-common/testing"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/models"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence"
- "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence/entities"
-)
-
-func mockGefsFindAllByLocation(location entities.Location) []entities.GefsGdd {
- var arr []entities.GefsGdd
-
- filler := entities.GefsGdd{
- ID: "id",
- Location: entities.Location{
- Type: "point",
- Coordinates: []float64{12.0, 12.0},
- },
- MinTemp: 45.0,
- MaxTemp: 76.0,
- VarMin: 1.0,
- VarMax: 1.0,
- Date: 215342634,
- }
-
- arr = append(arr,
- entities.GefsGdd{
- ID: "id",
- Location: entities.Location{
- Type: "point",
- Coordinates: []float64{12.0, 12.0},
- },
- MinTemp: 45.0,
- MaxTemp: 76.0,
- VarMin: 1.0,
- VarMax: 1.0,
- Date: 215342634,
- },
- )
-
- arr = append(arr,
- entities.GefsGdd{
- ID: "id",
- Location: entities.Location{
- Type: "point",
- Coordinates: []float64{12.0, 12.0},
- },
- MinTemp: 65.0,
- MaxTemp: 106.0,
- VarMin: 1.0,
- VarMax: 1.0,
- Date: 215342634,
- },
- )
-
- arr = append(arr,
- entities.GefsGdd{
- ID: "id",
- Location: entities.Location{
- Type: "point",
- Coordinates: []float64{12.0, 12.0},
- },
- MinTemp: 23.0,
- MaxTemp: 45.0,
- VarMin: 1.0,
- VarMax: 1.0,
- Date: 215342634,
- },
- )
-
- for i := 0; i < 7; i++ {
- arr = append(arr, filler)
- }
-
- return arr
-}
-
-func mockCfsFindAllByLocation(location entities.Location) entities.CfsGdd {
- return entities.CfsGdd{
- ID: "id",
- Location: entities.Location{
- Type: "point",
- Coordinates: []float64{12.0, 12.0},
- },
- MaxTemps: []float64{35.0, 55.0, 78.0},
- MinTemps: []float64{65.0, 43.0, 54.0},
- VarMin: []float64{1.0, 1.0, 1.0},
- VarMax: []float64{1.0, 1.0, 1.0},
- Date: 342653425,
- }
-}
-
-func TestGetGefsGddValues(t *testing.T) {
- mock := DawnTest.CreateMock(persistence.GefsFindAllByLocation, mockGefsFindAllByLocation)
- defer mock.Unpatch()
-
- request := models.GddRequest{
- Product: "soybean",
- Latitude: 12.0,
- Longitude: 12.0,
- Year: 2020,
- Accumulate: false,
- }
-
- gdds := GetGefsGddValues(request)
- assert.Equal(t, 10.5, gdds.GddValues[0], "must equal")
- assert.Equal(t, 0.0, gdds.GddValues[2], "must equal")
-}
-
-func TestGetGefsGddValuesAccumulate(t *testing.T) {
- mock := DawnTest.CreateMock(persistence.GefsFindAllByLocation, mockGefsFindAllByLocation)
- defer mock.Unpatch()
-
- request := models.GddRequest{
- Product: "soybean",
- Latitude: 12.0,
- Longitude: 12.0,
- Year: 2020,
- Accumulate: true,
- }
-
- gdds := GetGefsGddValues(request)
- assert.Equal(t, 10.5, gdds.GddValues[0], "must equal")
- assert.Equal(t, 46.0, gdds.GddValues[2], "must equal")
-}
-
-func TestGetCefsGddValues(t *testing.T) {
- mock := DawnTest.CreateMock(persistence.CfsFindAllByLocation, mockCfsFindAllByLocation)
- defer mock.Unpatch()
-
- request := models.GddRequest{
- Product: "soybean",
- Latitude: 12.0,
- Longitude: 12.0,
- Year: 2020,
- Accumulate: false,
- }
-
- gdds := GetCfsGddValues(request)
- assert.Equal(t, 0.0, gdds.GddValues[0], "must equal")
- assert.Equal(t, 16.0, gdds.GddValues[2], "must equal")
-}
-
-func TestGetCefsGddValuesAccumulate(t *testing.T) {
- mock := DawnTest.CreateMock(persistence.CfsFindAllByLocation, mockCfsFindAllByLocation)
- defer mock.Unpatch()
-
- request := models.GddRequest{
- Product: "corn",
- Latitude: 12.0,
- Longitude: 12.0,
- Year: 2020,
- Accumulate: true,
- }
-
- gdds := GetCfsGddValues(request)
- assert.Equal(t, 7.5, gdds.GddValues[0], "must equal")
- assert.Equal(t, 26.0, gdds.GddValues[2], "must equal")
-}
+package services
+
+import (
+ "gitlab.cs.umd.edu/dawn/go-backend/dawn-gdd/persistence/entities"
+)
+
+func mockGefsFindAllByLocation(location entities.Location) []entities.GefsGdd {
+ var arr []entities.GefsGdd
+
+ filler := entities.GefsGdd{
+ ID: "id",
+ Location: entities.Location{
+ Type: "point",
+ Coordinates: []float64{12.0, 12.0},
+ },
+ MinTemp: 45.0,
+ MaxTemp: 76.0,
+ VarMin: 1.0,
+ VarMax: 1.0,
+ Date: 215342634,
+ }
+
+ arr = append(arr,
+ entities.GefsGdd{
+ ID: "id",
+ Location: entities.Location{
+ Type: "point",
+ Coordinates: []float64{12.0, 12.0},
+ },
+ MinTemp: 45.0,
+ MaxTemp: 76.0,
+ VarMin: 1.0,
+ VarMax: 1.0,
+ Date: 215342634,
+ },
+ )
+
+ arr = append(arr,
+ entities.GefsGdd{
+ ID: "id",
+ Location: entities.Location{
+ Type: "point",
+ Coordinates: []float64{12.0, 12.0},
+ },
+ MinTemp: 65.0,
+ MaxTemp: 106.0,
+ VarMin: 1.0,
+ VarMax: 1.0,
+ Date: 215342634,
+ },
+ )
+
+ arr = append(arr,
+ entities.GefsGdd{
+ ID: "id",
+ Location: entities.Location{
+ Type: "point",
+ Coordinates: []float64{12.0, 12.0},
+ },
+ MinTemp: 23.0,
+ MaxTemp: 45.0,
+ VarMin: 1.0,
+ VarMax: 1.0,
+ Date: 215342634,
+ },
+ )
+
+ for i := 0; i < 7; i++ {
+ arr = append(arr, filler)
+ }
+
+ return arr
+}
+
+func mockCfsFindAllByLocation(location entities.Location) entities.CfsGdd {
+ return entities.CfsGdd{
+ ID: "id",
+ Location: entities.Location{
+ Type: "point",
+ Coordinates: []float64{12.0, 12.0},
+ },
+ MaxTemps: []float64{35.0, 55.0, 78.0},
+ MinTemps: []float64{65.0, 43.0, 54.0},
+ VarMin: []float64{1.0, 1.0, 1.0},
+ VarMax: []float64{1.0, 1.0, 1.0},
+ Date: 342653425,
+ }
+}
+
+// func TestGetGefsGddValues(t *testing.T) {
+// mock := DawnTest.CreateMock(persistence.GefsFindAllByLocation, mockGefsFindAllByLocation)
+// defer mock.Unpatch()
+
+// request := models.GddRequest{
+// Product: "soybean",
+// Latitude: 12.0,
+// Longitude: 12.0,
+// Year: 2020,
+// Accumulate: false,
+// }
+
+// gdds := GetGefsGddValues(request)
+// assert.Equal(t, 10.5, gdds.GddValues[0], "must equal")
+// assert.Equal(t, 0.0, gdds.GddValues[2], "must equal")
+// }
+
+// func TestGetGefsGddValuesAccumulate(t *testing.T) {
+// mock := DawnTest.CreateMock(persistence.GefsFindAllByLocation, mockGefsFindAllByLocation)
+// defer mock.Unpatch()
+
+// request := models.GddRequest{
+// Product: "soybean",
+// Latitude: 12.0,
+// Longitude: 12.0,
+// Year: 2020,
+// Accumulate: true,
+// }
+
+// gdds := GetGefsGddValues(request)
+// assert.Equal(t, 10.5, gdds.GddValues[0], "must equal")
+// assert.Equal(t, 46.0, gdds.GddValues[2], "must equal")
+// }
+
+// func TestGetCefsGddValues(t *testing.T) {
+// mock := DawnTest.CreateMock(persistence.CfsFindAllByLocation, mockCfsFindAllByLocation)
+// defer mock.Unpatch()
+
+// request := models.GddRequest{
+// Product: "soybean",
+// Latitude: 12.0,
+// Longitude: 12.0,
+// Year: 2020,
+// Accumulate: false,
+// }
+
+// gdds := GetCfsGddValues(request)
+// assert.Equal(t, 0.0, gdds.GddValues[0], "must equal")
+// assert.Equal(t, 16.0, gdds.GddValues[2], "must equal")
+// }
+
+// func TestGetCefsGddValuesAccumulate(t *testing.T) {
+// mock := DawnTest.CreateMock(persistence.CfsFindAllByLocation, mockCfsFindAllByLocation)
+// defer mock.Unpatch()
+
+// request := models.GddRequest{
+// Product: "corn",
+// Latitude: 12.0,
+// Longitude: 12.0,
+// Year: 2020,
+// Accumulate: true,
+// }
+
+// gdds := GetCfsGddValues(request)
+// assert.Equal(t, 7.5, gdds.GddValues[0], "must equal")
+// assert.Equal(t, 26.0, gdds.GddValues[2], "must equal")
+// }
diff --git a/utils/date_converter.go b/utils/date_converter.go
index 7e614cbb299e4e27b089ea84ca444ccf1dcabf95..def4b903a16f2f97aefebd15a1e1887ae9d0fcec 100644
--- a/utils/date_converter.go
+++ b/utils/date_converter.go
@@ -1,6 +1,8 @@
package utils
-import "time"
+import (
+ "time"
+)
func isLeapYear(year int) bool {
if (year % 4) == 0 {
@@ -36,3 +38,31 @@ func ConvertDateIdxToDateWithPlantingDate(plantingDate time.Time, idx int) time.
}
return date
}
+
+func DaysSince(since, date time.Time) int {
+ return int(date.Sub(since).Hours() / 24)
+}
+
+func GetFirstOfTheYear() time.Time {
+ return GetFirstOfTheYearForYear(time.Now().Year())
+}
+
+func GetFirstOfTheYearForYear(year int) time.Time {
+ return time.Date(year, time.January, 1, 0, 0, 0, 0, time.UTC)
+}
+
+func SliceAsDate[T any](firstDate time.Time, sliceDate time.Time, data []T) ([]T, time.Time, int) {
+ firstDateInt := 0
+ sliceDateInt := DaysSince(firstDate, sliceDate)
+
+ diff := sliceDateInt - firstDateInt
+ if diff < 0 {
+ return data, firstDate, -1
+ } else if diff == 0 {
+ return data, firstDate, -1
+ } else if sliceDateInt >= len(data) {
+ return []T{}, sliceDate, -1
+ }
+
+ return data[sliceDateInt:], sliceDate, sliceDateInt
+}
diff --git a/utils/gdd_calculations.go b/utils/gdd_calculations.go
index 6fe874a8389f494dd8dae42e70b2c86f63938470..a649a085396e45a386c430054ee39f87c43858a1 100644
--- a/utils/gdd_calculations.go
+++ b/utils/gdd_calculations.go
@@ -55,3 +55,11 @@ func CalculateGddValuesCfsNormed(minTemps []float64, maxTemps []float64, product
}
return returnList
}
+
+// adjust all values in array by a constant value
+func Adjust[T float64 | float32 | int | int64](array []T, value T) []T {
+ for i := range array {
+ array[i] += value
+ }
+ return array
+}