325 lines
7.0 KiB
Go
325 lines
7.0 KiB
Go
package main
|
|
|
|
import (
|
|
"github.com/jbowtie/gokogiri"
|
|
"github.com/pebbe/util"
|
|
|
|
"bytes"
|
|
"encoding/xml"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type Rss struct {
|
|
XMLName xml.Name `xml:"feed"`
|
|
Items []ItemT `xml:"entry"`
|
|
}
|
|
|
|
type ItemT struct {
|
|
Title TitleT `xml:"title"`
|
|
Published string `xml:"published"`
|
|
Updated string `xml:"updated"`
|
|
Nstag []string `xml:"nstag"`
|
|
Nslabeltag []string `xml:"nslabeltag"`
|
|
UnixTime int64 `xml:"unixTime"`
|
|
ID string `xml:"id"`
|
|
Link []LinkT `xml:"link"`
|
|
Data []byte `xml:",innerxml"`
|
|
}
|
|
|
|
type TitleT struct {
|
|
Type string `xml:"type,attr"`
|
|
Text string `xml:",chardata"`
|
|
}
|
|
|
|
type LinkT struct {
|
|
Type string `xml:"type,attr"`
|
|
Href string `xml:"href,attr"`
|
|
}
|
|
|
|
var (
|
|
x = util.CheckErr
|
|
w = util.WarnErr
|
|
// agent = "AhrefsBot/7.0"
|
|
agent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36"
|
|
)
|
|
|
|
func exists(filename string) bool {
|
|
_, err := os.Stat(filename)
|
|
return err == nil
|
|
}
|
|
|
|
func fileDate(filename string) string {
|
|
b, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
s := string(b)
|
|
i1 := strings.Index(s, "<unixTime>") + 10
|
|
i2 := strings.Index(s, "</unixTime>")
|
|
return s[i1:i2]
|
|
}
|
|
|
|
func main() {
|
|
resp, err := http.Get("https://www.vrt.be/vrtnws/nl.rss.headlines.xml")
|
|
x(err)
|
|
body, err := io.ReadAll(resp.Body)
|
|
x(err)
|
|
x(resp.Body.Close())
|
|
|
|
var rss Rss
|
|
x(xml.Unmarshal(body, &rss))
|
|
|
|
if len(rss.Items) == 0 {
|
|
x(fmt.Errorf("len(rss.Items) == 0"))
|
|
}
|
|
|
|
for _, item := range rss.Items {
|
|
t, err := time.Parse(time.RFC3339Nano, item.Published)
|
|
if err != nil {
|
|
t, err = time.Parse(time.RFC1123, item.Published)
|
|
}
|
|
x(err)
|
|
t2, err := time.Parse(time.RFC3339Nano, item.Updated)
|
|
if err != nil {
|
|
t2, _ = time.Parse(time.RFC1123, item.Updated)
|
|
}
|
|
if t2.After(t) {
|
|
t = t2
|
|
}
|
|
year, week := t.ISOWeek()
|
|
dirname := fmt.Sprintf("/net/corpora/nlnieuws/VRT/%d/%02d", year, week)
|
|
if exists(dirname + "/lock") {
|
|
continue
|
|
}
|
|
filename := dirname + "/" + url.PathEscape(strings.TrimPrefix(item.ID, "https://vrtnws.be/"))
|
|
|
|
ts := fmt.Sprintf("%d", t.Unix())
|
|
needUpdate := fileDate(filename+".xml") != ts
|
|
|
|
x(os.MkdirAll(dirname, 0777))
|
|
fp, err := os.Create(filename + ".xml")
|
|
x(err)
|
|
_, err = fp.WriteString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<item>\n")
|
|
x(err)
|
|
_, err = fmt.Fprintf(fp, "<unixTime>%d</unixTime>", t.Unix())
|
|
x(err)
|
|
_, err = fp.Write(item.Data)
|
|
x(err)
|
|
_, err = fp.WriteString("</item>\n")
|
|
x(err)
|
|
x(fp.Close())
|
|
x(os.Chtimes(filename+".xml", t, t))
|
|
|
|
var link string
|
|
for _, l := range item.Link {
|
|
if l.Type == "text/html" {
|
|
link = l.Href
|
|
}
|
|
}
|
|
if !doArticle(filename, link, item.Title.Text, item.Nstag, item.Nslabeltag, t, needUpdate) {
|
|
x(os.Remove(filename + ".xml"))
|
|
}
|
|
}
|
|
}
|
|
|
|
func doArticle(filename string, url string, title string, tags []string, labels []string, timestamp time.Time, needUpdate bool) bool {
|
|
if needUpdate {
|
|
_ = os.Remove(filename + ".err")
|
|
_ = os.Remove(filename + ".txt")
|
|
_ = os.Remove(filename + ".html")
|
|
_ = os.Remove(filename + ".skip")
|
|
} else {
|
|
if exists(filename+".txt") || exists(filename+".skip") {
|
|
return true
|
|
}
|
|
}
|
|
time.Sleep(2 * time.Second)
|
|
|
|
req, err := http.NewRequest("GET", url, nil)
|
|
x(err)
|
|
req.Header.Set("User-Agent", agent)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
x(err)
|
|
body, err := io.ReadAll(resp.Body)
|
|
x(err)
|
|
x(resp.Body.Close())
|
|
|
|
/*
|
|
s := string(body)
|
|
ok := true
|
|
i1 := strings.Index(s, `type="application/ld+json"`)
|
|
if i1 < 0 {
|
|
ok = false
|
|
} else {
|
|
i1 += strings.Index(s[i1:], `>`) + 1
|
|
i2 := i1 + strings.Index(s[i1:], `</script>`)
|
|
if i2 < i1 {
|
|
ok = false
|
|
} else {
|
|
s = s[i1:i2]
|
|
}
|
|
}
|
|
if !ok {
|
|
_ = w(fmt.Errorf("script jsonld not found: %s", url))
|
|
|
|
fp, err := os.Create(filename + ".err")
|
|
x(err)
|
|
_, err = fmt.Fprintf(fp, "script jsonld not found: %s\n", url)
|
|
x(err)
|
|
x(fp.Close())
|
|
x(os.Chtimes(filename+".err", timestamp, timestamp))
|
|
|
|
fp, err = os.Create(filename + ".html")
|
|
x(err)
|
|
_, err = fp.Write(body)
|
|
x(err)
|
|
x(fp.Close())
|
|
x(os.Chtimes(filename+".html", timestamp, timestamp))
|
|
|
|
return false
|
|
}
|
|
fp, err := os.Create(filename + ".json")
|
|
x(err)
|
|
_, err = fp.WriteString(s)
|
|
x(err)
|
|
x(fp.Close())
|
|
x(os.Chtimes(filename+".json", timestamp, timestamp))
|
|
*/
|
|
|
|
var buf bytes.Buffer
|
|
|
|
doc, err := gokogiri.ParseHtml(body)
|
|
x(err)
|
|
|
|
root := doc.Root()
|
|
|
|
lnn, err := root.Search(`//head/link[@rel="canonical"]/@href`)
|
|
x(err)
|
|
for _, ln := range lnn {
|
|
if strings.Contains(ln.String(), "/liveblog/") {
|
|
fp, err := os.Create(filename + ".skip")
|
|
x(err)
|
|
_, err = fp.WriteString("liveblog\n")
|
|
x(err)
|
|
x(fp.Close())
|
|
x(os.Chtimes(filename+".skip", timestamp, timestamp))
|
|
return true
|
|
}
|
|
}
|
|
|
|
if len(tags) == 0 {
|
|
_, err = fmt.Fprintln(&buf, "##META text cat =")
|
|
x(err)
|
|
} else {
|
|
for _, tag := range tags {
|
|
_, err = fmt.Fprintf(&buf, "##META text cat = %s\n", fixSpace(tag))
|
|
x(err)
|
|
}
|
|
}
|
|
if len(labels) == 0 {
|
|
_, err = fmt.Fprintln(&buf, "##META text label =")
|
|
x(err)
|
|
} else {
|
|
for _, label := range labels {
|
|
_, err = fmt.Fprintf(&buf, "##META text label = %s\n", fixSpace(label))
|
|
x(err)
|
|
}
|
|
}
|
|
|
|
_, err = buf.WriteString(addEnd(fixSpace(title)))
|
|
x(err)
|
|
|
|
fouten := make([]string, 0)
|
|
|
|
found := false
|
|
pp, err := root.Search(`//div[@data-sentry-component="ArticleHeading"]//*[contains(@class,"prose-article-body-r")]`)
|
|
x(err)
|
|
for _, p := range pp {
|
|
_, err = fmt.Fprint(&buf, addEnd(fixSpace(p.Content())))
|
|
x(err)
|
|
found = true
|
|
}
|
|
if !found {
|
|
fouten = append(fouten, fmt.Sprintf("no heading: %s", url))
|
|
_ = w(fmt.Errorf("no heading: %s", url))
|
|
}
|
|
|
|
found = false
|
|
pp, err = root.Search(
|
|
`//div[@data-sentry-component="ArticleText"]//*[contains(@class,"prose-article-body-r")]` +
|
|
` | ` +
|
|
`//div[@data-sentry-component="ArticleTitle"]//h2`)
|
|
x(err)
|
|
for _, p := range pp {
|
|
_, err = fmt.Fprint(&buf, addEnd(fixSpace(p.Content())))
|
|
x(err)
|
|
found = true
|
|
}
|
|
if !found {
|
|
fouten = append(fouten, fmt.Sprintf("no text: %s", url))
|
|
_ = w(fmt.Errorf("no text: %s", url))
|
|
}
|
|
|
|
if len(fouten) > 0 {
|
|
fp, err := os.Create(filename + ".err")
|
|
x(err)
|
|
for _, fout := range fouten {
|
|
_, err = fp.WriteString(fout)
|
|
x(err)
|
|
}
|
|
x(err)
|
|
x(fp.Close())
|
|
x(os.Chtimes(filename+".err", timestamp, timestamp))
|
|
|
|
fp, err = os.Create(filename + ".html")
|
|
x(err)
|
|
_, err = fp.Write(body)
|
|
x(err)
|
|
x(fp.Close())
|
|
x(os.Chtimes(filename+".html", timestamp, timestamp))
|
|
|
|
return false
|
|
}
|
|
|
|
fp, err := os.Create(filename + ".txt")
|
|
x(err)
|
|
_, err = fp.Write(buf.Bytes())
|
|
x(err)
|
|
x(fp.Close())
|
|
x(os.Chtimes(filename+".txt", timestamp, timestamp))
|
|
|
|
return true
|
|
}
|
|
|
|
func addEnd(s string) string {
|
|
s = strings.TrimSpace(s)
|
|
n := len(s)
|
|
if n == 0 {
|
|
return ""
|
|
}
|
|
if n > 0 {
|
|
if strings.ContainsAny(s[n-1:], ".!?") {
|
|
return s + "\n"
|
|
}
|
|
}
|
|
if n > 1 {
|
|
s2 := s[n-2:]
|
|
if s2 == `."` || s2 == `!"` || s2 == `?"` || s2 == `.'` || s2 == `!'` || s2 == `?'` {
|
|
return s + "\n"
|
|
}
|
|
}
|
|
return s + ".\n"
|
|
}
|
|
|
|
func fixSpace(s string) string {
|
|
return strings.Join(strings.Fields(s), " ")
|
|
}
|