152 lines
3.2 KiB
Go
152 lines
3.2 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
|
|
"git.ctrlz.es/mgdelacroix/bookworm/templates"
|
|
|
|
miniflux "miniflux.app/client"
|
|
)
|
|
|
|
type Config struct {
|
|
Title string `json:"title"`
|
|
MinifluxURL string `json:"miniflux_url"`
|
|
MinifluxUsername string `json:"miniflux_username"`
|
|
MinifluxPassword string `json:"miniflux_password"`
|
|
MinifluxAPI string `json:"miniflux_api"`
|
|
MinifluxCategory string `json:"miniflux_category"`
|
|
}
|
|
|
|
func (c *Config) IsValid() error {
|
|
if c.Title == "" {
|
|
return fmt.Errorf("title is required")
|
|
}
|
|
|
|
if c.MinifluxURL == "" {
|
|
return fmt.Errorf("miniflux_url is required")
|
|
}
|
|
|
|
if c.MinifluxAPI == "" && (c.MinifluxUsername == "" || c.MinifluxPassword == "") {
|
|
return fmt.Errorf("either miniflux_api or miniflux_username and miniflux_password need to be set")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func ReadConfig(name string) (*Config, error) {
|
|
b, err := os.ReadFile(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var cfg Config
|
|
if err := json.Unmarshal(b, &cfg); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &cfg, nil
|
|
}
|
|
|
|
func createClient(cfg *Config) (*miniflux.Client, error) {
|
|
var client *miniflux.Client
|
|
if cfg.MinifluxAPI != "" {
|
|
client = miniflux.New(cfg.MinifluxURL, cfg.MinifluxAPI)
|
|
} else {
|
|
client = miniflux.New(cfg.MinifluxURL, cfg.MinifluxUsername, cfg.MinifluxPassword)
|
|
}
|
|
|
|
if _, err := client.Me(); err != nil {
|
|
return nil, fmt.Errorf("cannot get \"me\" with newly created client: %w", err)
|
|
}
|
|
|
|
return client, nil
|
|
}
|
|
|
|
func checkErr(err error) {
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "error: %s\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func listCategories(cfg *Config, client *miniflux.Client) error {
|
|
categories, err := client.Categories()
|
|
if err != nil {
|
|
return fmt.Errorf("cannot fetch categories: %w", err)
|
|
}
|
|
|
|
if len(categories) != 0 {
|
|
fmt.Println("Category list")
|
|
}
|
|
for _, c := range categories {
|
|
fmt.Printf("- %s\n", c.Title)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func main() {
|
|
cfgFlag := flag.String("config", "bookworm.json", "path to the configuration file")
|
|
listCategoriesFlag := flag.Bool("list-categories", false, "lists the categories of the remote Miniflux instance")
|
|
flag.Parse()
|
|
|
|
cfg, err := ReadConfig(*cfgFlag)
|
|
checkErr(err)
|
|
|
|
cErr := cfg.IsValid()
|
|
checkErr(cErr)
|
|
|
|
client, cliErr := createClient(cfg)
|
|
checkErr(cliErr)
|
|
|
|
if *listCategoriesFlag {
|
|
listCategories(cfg, client)
|
|
return
|
|
}
|
|
|
|
var feeds miniflux.Feeds
|
|
var fErr error
|
|
if cfg.MinifluxCategory != "" {
|
|
categories, catErr := client.Categories()
|
|
if catErr != nil {
|
|
checkErr(fmt.Errorf("can't get categories: %w", catErr))
|
|
}
|
|
|
|
var category *miniflux.Category
|
|
for _, c := range categories {
|
|
if c.Title == cfg.MinifluxCategory {
|
|
category = c
|
|
break
|
|
}
|
|
}
|
|
|
|
if category == nil {
|
|
checkErr(fmt.Errorf("can't find category %q", cfg.MinifluxCategory))
|
|
}
|
|
|
|
feeds, fErr = client.CategoryFeeds(category.ID)
|
|
} else {
|
|
feeds, fErr = client.Feeds()
|
|
}
|
|
checkErr(fErr)
|
|
|
|
data := struct {
|
|
Title string
|
|
OldestArticle int
|
|
MaxArticlesPerFeed int
|
|
Feeds miniflux.Feeds
|
|
}{
|
|
Title: cfg.Title,
|
|
OldestArticle: 7,
|
|
MaxArticlesPerFeed: 100,
|
|
Feeds: feeds,
|
|
}
|
|
|
|
s, tErr := templates.Execute(data)
|
|
checkErr(tErr)
|
|
|
|
checkErr(os.WriteFile("out.recipe", s, 0755))
|
|
}
|