mirror of
https://github.com/chubin/wttr.in
synced 2025-01-27 11:05:07 +00:00
142 lines
3.2 KiB
Go
142 lines
3.2 KiB
Go
package location
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path"
|
|
"strings"
|
|
|
|
"github.com/samonzeweb/godb"
|
|
"github.com/samonzeweb/godb/adapters/sqlite"
|
|
"github.com/zsefvlol/timezonemapper"
|
|
|
|
"github.com/chubin/wttr.in/internal/config"
|
|
"github.com/chubin/wttr.in/internal/types"
|
|
)
|
|
|
|
// Cache is an implemenation of DB/file-based cache.
|
|
//
|
|
// At the moment, it is an implementation for the location cache,
|
|
// but it should be generalized to cache everything.
|
|
type Cache struct {
|
|
config *config.Config
|
|
db *godb.DB
|
|
indexField string
|
|
filesCacheDir string
|
|
}
|
|
|
|
// NewCache returns new cache reader for the specified config.
|
|
func NewCache(config *config.Config) (*Cache, error) {
|
|
var (
|
|
db *godb.DB
|
|
err error
|
|
)
|
|
|
|
if config.Geo.LocationCacheType == types.CacheTypeDB {
|
|
db, err = godb.Open(sqlite.Adapter, config.Geo.IPCacheDB)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Needed for "upsert" implementation in Put()
|
|
db.UseErrorParser()
|
|
}
|
|
|
|
return &Cache{
|
|
config: config,
|
|
db: db,
|
|
indexField: "name",
|
|
filesCacheDir: config.Geo.LocationCache,
|
|
}, nil
|
|
}
|
|
|
|
// Read returns location information from the cache, if found,
|
|
// or types.ErrNotFound if not found. If the entry is found, but its format
|
|
// is invalid, types.ErrInvalidCacheEntry is returned.
|
|
func (c *Cache) Read(addr string) (*Location, error) {
|
|
if c.config.Geo.LocationCacheType == types.CacheTypeFiles {
|
|
return c.readFromCacheFile(addr)
|
|
}
|
|
|
|
return c.readFromCacheDB(addr)
|
|
}
|
|
|
|
func (c *Cache) readFromCacheFile(name string) (*Location, error) {
|
|
var (
|
|
fileLoc = struct {
|
|
Latitude float64 `json:"latitude"`
|
|
Longitude float64 `json:"longitude"`
|
|
Timezone string `json:"timezone"`
|
|
Address string `json:"address"`
|
|
}{}
|
|
location Location
|
|
)
|
|
|
|
bytes, err := os.ReadFile(c.cacheFile(name))
|
|
if err != nil {
|
|
return nil, types.ErrNotFound
|
|
}
|
|
err = json.Unmarshal(bytes, &fileLoc)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// normalize name
|
|
name = strings.TrimSpace(
|
|
strings.TrimRight(
|
|
strings.TrimLeft(name, `"`), `"`))
|
|
|
|
timezone := fileLoc.Timezone
|
|
if timezone == "" {
|
|
timezone = timezonemapper.LatLngToTimezoneString(fileLoc.Latitude, fileLoc.Longitude)
|
|
}
|
|
|
|
location = Location{
|
|
Name: name,
|
|
Lat: fmt.Sprint(fileLoc.Latitude),
|
|
Lon: fmt.Sprint(fileLoc.Longitude),
|
|
Timezone: timezone,
|
|
Fullname: fileLoc.Address,
|
|
}
|
|
|
|
return &location, nil
|
|
}
|
|
|
|
func (c *Cache) readFromCacheDB(addr string) (*Location, error) {
|
|
result := Location{}
|
|
err := c.db.Select(&result).
|
|
Where(c.indexField+" = ?", addr).
|
|
Do()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &result, nil
|
|
}
|
|
|
|
func (c *Cache) Put(addr string, loc *Location) error {
|
|
if c.config.Geo.IPCacheType == types.CacheTypeDB {
|
|
return c.putToCacheDB(loc)
|
|
}
|
|
|
|
return c.putToCacheFile(addr, loc)
|
|
}
|
|
|
|
func (c *Cache) putToCacheDB(loc *Location) error {
|
|
err := c.db.Insert(loc).Do()
|
|
if strings.Contains(fmt.Sprint(err), "UNIQUE constraint failed") {
|
|
return c.db.Update(loc).Do()
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
func (c *Cache) putToCacheFile(addr string, loc fmt.Stringer) error {
|
|
return os.WriteFile(c.cacheFile(addr), []byte(loc.String()), 0o600)
|
|
}
|
|
|
|
// cacheFile returns path to the cache entry for addr.
|
|
func (c *Cache) cacheFile(item string) string {
|
|
return path.Join(c.filesCacheDir, item)
|
|
}
|