297 lines
7.7 KiB
Go
297 lines
7.7 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"embed"
|
|
"encoding/base64"
|
|
"fmt"
|
|
"html/template"
|
|
"log"
|
|
"math"
|
|
"net/http"
|
|
"os"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/ChimeraCoder/anaconda"
|
|
strip "github.com/grokify/html-strip-tags-go"
|
|
"github.com/joho/godotenv"
|
|
"github.com/patrickmn/go-cache"
|
|
"github.com/rivo/uniseg"
|
|
emoji "github.com/tmdvs/Go-Emoji-Utils"
|
|
)
|
|
|
|
//go:embed index.html tweet.svg.tmpl suspendedTweet.svg
|
|
|
|
var content embed.FS
|
|
|
|
var (
|
|
api *anaconda.TwitterApi
|
|
|
|
tweetDateLayout = "Mon Jan 2 15:04:05 -0700 2006"
|
|
|
|
port string
|
|
accessToken string
|
|
accessTokenSecret string
|
|
consumerKey string
|
|
consumerSecret string
|
|
|
|
ch *cache.Cache
|
|
)
|
|
|
|
func init() {
|
|
godotenv.Load(os.Getenv("DOTENV_DIR") + ".env")
|
|
|
|
port = os.Getenv("PORT")
|
|
accessToken = os.Getenv("ACCESS_TOKEN")
|
|
accessTokenSecret = os.Getenv("ACCESS_TOKEN_SECRET")
|
|
consumerKey = os.Getenv("CONSUMER_KEY")
|
|
consumerSecret = os.Getenv("CONSUMER_SECRET")
|
|
|
|
ch = cache.New(24*time.Hour, 48*time.Hour)
|
|
}
|
|
|
|
func main() {
|
|
if accessToken == "" || accessTokenSecret == "" || consumerKey == "" || consumerSecret == "" {
|
|
panic("Missing Twitter credentials")
|
|
}
|
|
|
|
api = anaconda.NewTwitterApiWithCredentials(accessToken, accessTokenSecret, consumerKey, consumerSecret)
|
|
|
|
if port == "" {
|
|
port = "8080"
|
|
}
|
|
|
|
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
if len(r.URL.Path) > 1 {
|
|
getTweet(w, r)
|
|
} else {
|
|
body, _ := content.ReadFile("index.html")
|
|
w.Write(body)
|
|
}
|
|
})
|
|
fmt.Println("Server started at port " + port)
|
|
log.Fatal(http.ListenAndServe(":"+port, nil))
|
|
}
|
|
|
|
func getTweet(w http.ResponseWriter, r *http.Request) {
|
|
id := strings.ReplaceAll(r.URL.Path, "/", "")
|
|
i, err := strconv.ParseInt(id, 10, 64)
|
|
if err != nil {
|
|
w.WriteHeader(400)
|
|
return
|
|
}
|
|
|
|
result, found := ch.Get(id)
|
|
if !found {
|
|
fmt.Println("No cached tweet found, generating new...")
|
|
tweet, err := api.GetTweet(i, nil)
|
|
if err != nil {
|
|
switch err := err.(type) {
|
|
case *anaconda.ApiError:
|
|
switch err.Decoded.Errors[0].Code {
|
|
case 63:
|
|
fmt.Printf("Generating suspended tweet image for %s\n", id)
|
|
suspendedTweet(w)
|
|
return
|
|
}
|
|
}
|
|
fmt.Println(err)
|
|
w.WriteHeader(404)
|
|
return
|
|
}
|
|
|
|
processTweet(&tweet)
|
|
|
|
result = renderTemplate(tweet, false)
|
|
ch.Set(id, result, cache.DefaultExpiration)
|
|
}
|
|
|
|
w.Header().Set("Content-type", "image/svg+xml")
|
|
_, err = w.Write(result.([]byte))
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
w.WriteHeader(500)
|
|
return
|
|
}
|
|
}
|
|
|
|
func processTweet(tweet *anaconda.Tweet) {
|
|
gr := uniseg.NewGraphemes(tweet.FullText)
|
|
count := 0
|
|
displayText := ""
|
|
for gr.Next() {
|
|
if count >= tweet.DisplayTextRange[0] && count < tweet.DisplayTextRange[1] {
|
|
displayText += gr.Str()
|
|
}
|
|
count += 1
|
|
}
|
|
tweet.FullText = displayText
|
|
|
|
for _, user := range tweet.Entities.User_mentions {
|
|
tweet.FullText = strings.ReplaceAll(tweet.FullText, "@"+user.Screen_name, fmt.Sprintf("<a rel=\"noopener\" target=\"_blank\" href=\"https://twitter.com/%s/\">@%s</a>", user.Screen_name, user.Screen_name))
|
|
}
|
|
for _, url := range tweet.Entities.Urls {
|
|
tweet.FullText = strings.ReplaceAll(tweet.FullText, url.Url, fmt.Sprintf("<a rel=\"noopener\" target=\"_blank\" href=\"%s\">%s</a>", url.Expanded_url, url.Display_url))
|
|
}
|
|
for _, hashtag := range tweet.Entities.Hashtags {
|
|
tweet.FullText = strings.ReplaceAll(tweet.FullText, "#"+hashtag.Text, fmt.Sprintf("<a rel=\"noopener\" target=\"_blank\" href=\"https://twitter.com/hashtag/%s\">#%s</a>", hashtag.Text, hashtag.Text))
|
|
}
|
|
|
|
tweet.FullText = strings.ReplaceAll(tweet.FullText, "\n", "<br />")
|
|
|
|
if tweet.QuotedStatus != nil {
|
|
processTweet(tweet.QuotedStatus)
|
|
}
|
|
|
|
}
|
|
|
|
func renderTemplate(tweet anaconda.Tweet, isQuoted bool) []byte {
|
|
templateFuncs := template.FuncMap{
|
|
"base64": func(url string) string {
|
|
res, err := http.Get(url)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
buf := new(bytes.Buffer)
|
|
buf.ReadFrom(res.Body)
|
|
return base64.StdEncoding.EncodeToString(buf.Bytes())
|
|
},
|
|
"isoDate": func(date string) string {
|
|
t, _ := time.Parse(tweetDateLayout, date)
|
|
return t.Format(time.RFC3339)
|
|
},
|
|
"humanDate": func(date string) string {
|
|
t, _ := time.Parse(tweetDateLayout, date)
|
|
return t.Format("3:04 PM · Jan 2, 2006")
|
|
},
|
|
"html": func(in string) template.HTML {
|
|
return template.HTML(in)
|
|
},
|
|
"calculateHeight": func(tweet anaconda.Tweet) string {
|
|
return fmt.Sprintf("%dpx", calculateHeight(tweet))
|
|
},
|
|
"renderTweet": func(tweet anaconda.Tweet) template.HTML {
|
|
return template.HTML(string(renderTemplate(tweet, true)))
|
|
},
|
|
"tweetWidth": func() string {
|
|
if isQuoted {
|
|
return "450px"
|
|
}
|
|
return "499px"
|
|
},
|
|
"className": func() string {
|
|
if isQuoted {
|
|
return "subtweet"
|
|
}
|
|
return "tweetsvg"
|
|
},
|
|
}
|
|
|
|
t := template.Must(
|
|
template.New("tweet.svg.tmpl").
|
|
Funcs(templateFuncs).
|
|
ParseFS(content, "tweet.svg.tmpl"))
|
|
|
|
var buf bytes.Buffer
|
|
t.Execute(&buf, tweet)
|
|
|
|
return buf.Bytes()
|
|
}
|
|
|
|
func calculateHeight(tweet anaconda.Tweet) int64 {
|
|
height := 64.0 /* Avatar */ + 20 /* footer */ + 46 /* text margin */ + 22 /* margin */
|
|
|
|
lineWidth := 0.0
|
|
lineHeight := 28.0
|
|
tweetText := strings.ReplaceAll(tweet.FullText, "<br />", " \n")
|
|
tweetText = strip.StripTags(tweetText)
|
|
tweetText = strings.ReplaceAll(tweetText, "--", "——")
|
|
words := regexp.MustCompile(`[ |-]`).Split(tweetText, -1)
|
|
for _, word := range words {
|
|
word = strings.ReplaceAll(word, "——", "--")
|
|
if len(emoji.FindAll(word)) > 0 {
|
|
lineHeight = 32.0
|
|
}
|
|
|
|
if strings.HasPrefix(word, "\n") {
|
|
height += lineHeight
|
|
lineWidth = 0
|
|
word = strings.TrimPrefix(word, "\n")
|
|
}
|
|
|
|
if strings.Contains(word, "\n") {
|
|
height += lineHeight
|
|
lineHeight = 28.0
|
|
lineWidth = 0
|
|
continue
|
|
}
|
|
|
|
chars := strings.Split(word, "")
|
|
wordWidth := 0.0
|
|
for _, char := range chars {
|
|
wordWidth += getCharWidth(char)
|
|
}
|
|
|
|
if wordWidth > 435 {
|
|
height += (lineHeight * (math.Ceil(wordWidth/435) + 1))
|
|
lineHeight = 28.0
|
|
lineWidth = 0
|
|
} else if lineWidth+getCharWidth(" ")+wordWidth > 435 {
|
|
height += lineHeight
|
|
lineHeight = 28.0
|
|
lineWidth = wordWidth
|
|
} else {
|
|
lineWidth += wordWidth
|
|
}
|
|
}
|
|
if lineWidth > 0 {
|
|
height += lineHeight
|
|
}
|
|
|
|
if tweet.InReplyToScreenName != "" {
|
|
height += 42
|
|
}
|
|
|
|
for i, img := range tweet.ExtendedEntities.Media {
|
|
ratio := float64(img.Sizes.Small.W) / 468
|
|
tweet.ExtendedEntities.Media[i].Sizes.Small.W = 468
|
|
tweet.ExtendedEntities.Media[i].Sizes.Small.H = int((float64(img.Sizes.Small.H) / ratio) + 5.0)
|
|
}
|
|
|
|
if len(tweet.ExtendedEntities.Media) > 1 {
|
|
for i, img := range tweet.ExtendedEntities.Media {
|
|
tweet.ExtendedEntities.Media[i].Sizes.Small.W = (img.Sizes.Small.W / 2) - 20
|
|
tweet.ExtendedEntities.Media[i].Sizes.Small.H = (img.Sizes.Small.H / 2) - 20
|
|
}
|
|
}
|
|
|
|
switch len(tweet.ExtendedEntities.Media) {
|
|
case 1:
|
|
height += float64(tweet.ExtendedEntities.Media[0].Sizes.Small.H)
|
|
case 2:
|
|
height += math.Max(float64(tweet.ExtendedEntities.Media[0].Sizes.Small.H), float64(tweet.ExtendedEntities.Media[1].Sizes.Small.H)) + 5
|
|
case 3:
|
|
height += math.Max(float64(tweet.ExtendedEntities.Media[0].Sizes.Small.H), float64(tweet.ExtendedEntities.Media[1].Sizes.Small.H)) + 5
|
|
height += float64(tweet.ExtendedEntities.Media[2].Sizes.Small.H) + 35
|
|
case 4:
|
|
height += math.Max(float64(tweet.ExtendedEntities.Media[0].Sizes.Small.H), float64(tweet.ExtendedEntities.Media[1].Sizes.Small.H)) + 10
|
|
height += math.Max(float64(tweet.ExtendedEntities.Media[2].Sizes.Small.H), float64(tweet.ExtendedEntities.Media[3].Sizes.Small.H)) + 10
|
|
height += 7
|
|
}
|
|
|
|
if tweet.QuotedStatus != nil {
|
|
height += float64(calculateHeight(*tweet.QuotedStatus)) + 9
|
|
}
|
|
|
|
return int64(height)
|
|
}
|
|
|
|
func suspendedTweet(w http.ResponseWriter) {
|
|
w.Header().Set("Content-type", "image/svg+xml")
|
|
tweet, _ := content.ReadFile("suspendedTweet.svg")
|
|
w.Write(tweet)
|
|
}
|