146 lines
3.3 KiB
Go
146 lines
3.3 KiB
Go
package handlers
|
|
|
|
import (
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"veola/internal/db"
|
|
"veola/internal/models"
|
|
"veola/internal/scheduler"
|
|
"veola/templates"
|
|
)
|
|
|
|
const resultsPerPage = 20
|
|
|
|
func (a *App) GetItemResults(w http.ResponseWriter, r *http.Request) {
|
|
id := intParam(r, "id")
|
|
it, err := a.Store.GetItem(r.Context(), id)
|
|
if err != nil || it == nil {
|
|
http.NotFound(w, r)
|
|
return
|
|
}
|
|
|
|
order := r.URL.Query().Get("order")
|
|
if order == "" {
|
|
order = "found_desc"
|
|
}
|
|
page, _ := strconv.Atoi(r.URL.Query().Get("page"))
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
|
|
total, err := a.Store.CountResults(r.Context(), id)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
totalPages := (total + resultsPerPage - 1) / resultsPerPage
|
|
if totalPages < 1 {
|
|
totalPages = 1
|
|
}
|
|
if page > totalPages {
|
|
page = totalPages
|
|
}
|
|
|
|
results, err := a.Store.ListResults(r.Context(), db.ResultsQuery{
|
|
ItemID: id,
|
|
Limit: resultsPerPage,
|
|
Offset: (page - 1) * resultsPerPage,
|
|
Order: order,
|
|
})
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
history, err := a.Store.ListPriceHistory(r.Context(), id)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
badge := scheduler.PickBadge(*it, history, time.Now())
|
|
chart := buildChartJSON(history)
|
|
|
|
render(w, r, templates.ItemResults(templates.ItemResultsData{
|
|
Page: a.page(r, it.Name, "items"),
|
|
Item: *it,
|
|
Badge: badge,
|
|
History: history,
|
|
Results: results,
|
|
Page_: page,
|
|
TotalPages: totalPages,
|
|
Order: order,
|
|
HistoryChartJSON: chart,
|
|
}))
|
|
}
|
|
|
|
func buildChartJSON(history []models.PricePoint) string {
|
|
c := templates.ChartJSON{
|
|
Labels: make([]string, 0, len(history)),
|
|
Points: make([]float64, 0, len(history)),
|
|
}
|
|
for _, p := range history {
|
|
c.Labels = append(c.Labels, p.PolledAt.Format("2006-01-02"))
|
|
c.Points = append(c.Points, p.Price)
|
|
}
|
|
return templates.MustChartJSON(c)
|
|
}
|
|
|
|
func (a *App) GetGlobalResults(w http.ResponseWriter, r *http.Request) {
|
|
q := r.URL.Query()
|
|
itemID, _ := strconv.ParseInt(q.Get("item_id"), 10, 64)
|
|
from := strings.TrimSpace(q.Get("from"))
|
|
to := strings.TrimSpace(q.Get("to"))
|
|
|
|
items, err := a.Store.ListItems(r.Context())
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
names := make(map[int64]string, len(items))
|
|
for _, it := range items {
|
|
names[it.ID] = it.Name
|
|
}
|
|
|
|
results, err := a.Store.ListResults(r.Context(), db.ResultsQuery{
|
|
ItemID: itemID,
|
|
Limit: 200,
|
|
})
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
fromT, _ := time.Parse("2006-01-02", from)
|
|
toT, _ := time.Parse("2006-01-02", to)
|
|
if !toT.IsZero() {
|
|
toT = toT.Add(24 * time.Hour)
|
|
}
|
|
|
|
rows := make([]templates.ItemResultRow, 0, len(results))
|
|
for _, res := range results {
|
|
if !fromT.IsZero() && res.FoundAt.Before(fromT) {
|
|
continue
|
|
}
|
|
if !toT.IsZero() && !res.FoundAt.Before(toT) {
|
|
continue
|
|
}
|
|
rows = append(rows, templates.ItemResultRow{
|
|
Result: res,
|
|
ItemName: names[res.ItemID],
|
|
})
|
|
}
|
|
|
|
render(w, r, templates.GlobalResults(templates.GlobalResultsData{
|
|
Page: a.page(r, "Results", "results"),
|
|
Items: items,
|
|
Results: rows,
|
|
ItemID: itemID,
|
|
From: from,
|
|
To: to,
|
|
}))
|
|
}
|