148 lines
2.8 KiB
Go
148 lines
2.8 KiB
Go
package db
|
|
|
|
import (
|
|
"encoding/csv"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/go-logr/logr"
|
|
"go.balki.me/tss/parser"
|
|
)
|
|
|
|
var log = logr.Discard()
|
|
|
|
func SetLogger(l logr.Logger) {
|
|
log = l
|
|
}
|
|
|
|
type Status string
|
|
|
|
const (
|
|
Sent Status = "SENT"
|
|
Filtered Status = "FILTERED"
|
|
Error Status = "ERROR"
|
|
)
|
|
|
|
// TimeFormat used by yaml.Marshal
|
|
const TimeFormat string = "2006-01-02T15:04:05.999999999-07:00"
|
|
|
|
type Record struct {
|
|
Time time.Time
|
|
Status Status
|
|
Filter string
|
|
FeedEntry parser.FeedEntry
|
|
}
|
|
|
|
type DB interface {
|
|
IsNewFeed() bool
|
|
Filter(entries []parser.FeedEntry) ([]parser.FeedEntry, error)
|
|
Save([]Record) error
|
|
}
|
|
|
|
type db struct {
|
|
dbPath string
|
|
seenLinks map[string]struct{}
|
|
}
|
|
|
|
func (d *db) IsNewFeed() bool {
|
|
return len(d.seenLinks) == 0
|
|
}
|
|
|
|
func NewDB(storageDir, feedName string) (DB, error) {
|
|
dbPath := path.Join(storageDir, fmt.Sprintf("%s.csv", feedName))
|
|
db := db{
|
|
dbPath: dbPath,
|
|
seenLinks: map[string]struct{}{},
|
|
}
|
|
f, err := os.Open(dbPath)
|
|
if err != nil {
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
log.Info("db file does not exist, will be created", "feed", feedName, "path", dbPath)
|
|
return &db, nil
|
|
}
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
err := f.Close()
|
|
if err != nil {
|
|
log.Error(err, "f.Close() failed")
|
|
return
|
|
}
|
|
}()
|
|
reader := csv.NewReader(f)
|
|
records, err := reader.ReadAll()
|
|
if err != nil {
|
|
log.Error(err, "failed to parse csv", "path", dbPath)
|
|
return nil, err
|
|
}
|
|
for _, rec := range records {
|
|
recStatus := Status(rec[2])
|
|
if recStatus == Sent || recStatus == Filtered {
|
|
db.seenLinks[rec[1]] = struct{}{}
|
|
}
|
|
}
|
|
return &db, nil
|
|
}
|
|
|
|
func (d *db) Filter(entries []parser.FeedEntry) ([]parser.FeedEntry, error) {
|
|
var filteredEntries []parser.FeedEntry
|
|
for _, entry := range entries {
|
|
if _, ok := d.seenLinks[entry.Link]; !ok {
|
|
filteredEntries = append(filteredEntries, entry)
|
|
d.seenLinks[entry.Link] = struct{}{}
|
|
}
|
|
}
|
|
return filteredEntries, nil
|
|
}
|
|
|
|
func (d *db) Save(records []Record) error {
|
|
if len(records) == 0 {
|
|
return nil
|
|
}
|
|
|
|
f, err := os.OpenFile(d.dbPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() {
|
|
err := f.Close()
|
|
if err != nil {
|
|
log.Error(err, "f.Close() failed")
|
|
return
|
|
}
|
|
}()
|
|
|
|
csvw := csv.NewWriter(f)
|
|
defer csvw.Flush()
|
|
|
|
if d.IsNewFeed() {
|
|
err := csvw.Write([]string{
|
|
/* 1 */ "Date",
|
|
/* 2 */ "Link",
|
|
/* 3 */ "Status",
|
|
/* 4 */ "Filter",
|
|
/* 5 */ "Content",
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, r := range records {
|
|
err := csvw.Write([]string{
|
|
/* 1 */ r.Time.Format(TimeFormat),
|
|
/* 2 */ r.FeedEntry.Link,
|
|
/* 3 */ string(r.Status),
|
|
/* 4 */ r.Filter,
|
|
/* 5 */ fmt.Sprintf("<item>%s</item>", strings.ReplaceAll(r.FeedEntry.Content, "\n", " ")),
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|