kiki/tooter/tooter.go

package tooter

import (
	"context"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"os"
	"strings"

	"kiki/config"

	"github.com/mattn/go-mastodon"
	"github.com/mmcdole/gofeed"
	"golang.org/x/net/html"
	"gopkg.in/yaml.v2"
)

func ClientConfiguration(Instance string) {
	appConfig := &mastodon.AppConfig{
		Server:       Instance,
		ClientName:   "Kiki",
		Scopes:       "read write follow",
		Website:      "catgirls.asia",
		RedirectURIs: "urn:ietf:wg:oauth:2.0:oob",
	}

	app, err := mastodon.RegisterApp(context.Background(), appConfig)
	if err != nil {
		log.Println(err)
	}

	u, err := url.Parse(app.AuthURI)
	if err != nil {
		log.Println(err)
	}
	var userToken string
	//fmt.Println(u)
	fmt.Printf("Перейдите по ссылке\n%s\nИ введите user token ниже:\n", u)
	fmt.Scanln(&userToken)

	conf := &mastodon.Config{
		Server:       Instance,
		ClientID:     app.ClientID,
		ClientSecret: app.ClientSecret,
		AccessToken:  userToken,
	}

	mastoClient := mastodon.NewClient(conf)
	err = mastoClient.AuthenticateToken(context.Background(), userToken, "urn:ietf:wg:oauth:2.0:oob")
	if err != nil {
		log.Println(err)
	}

	clientData := config.MastodonClientData{
		Instance:     Instance,
		ClientID:     mastoClient.Config.ClientID,
		ClientSecret: mastoClient.Config.ClientSecret,
		AccessToken:  mastoClient.Config.AccessToken,
	}

	marshaledYaml, err := yaml.Marshal(clientData)
	if err != nil {
		log.Println(err)
	}

	log.Println(string(marshaledYaml))
	secretConfig, err := os.OpenFile("secret.conf", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o644)
	if err != nil {
		log.Println(err)
	}
	secretConfig.Write(marshaledYaml)
	defer secretConfig.Close()
}

func NewsText(url string) []*gofeed.Item {
	fp := gofeed.NewParser()
	feed, err := fp.ParseURL(url)
	if err != nil {
		log.Println(err)
	}
	log.Println("RSS лента получена")
	return feed.Items
}

func CreatePost(mastoClient mastodon.Client, toot mastodon.Toot) {
	_, err := mastoClient.PostStatus(context.Background(), &toot)
	if err != nil {
		log.Println(err)
	}
}

func PicBytesArray(picturesArray []string) [][]byte {
	var picturesBytes [][]byte
	for _, picture := range picturesArray {
		resp, err := http.Get(picture)
		if err != nil {
			log.Println(err)
			return picturesBytes
		}
		defer resp.Body.Close()
		picBytes, err := io.ReadAll(resp.Body)
		if err != nil {
			log.Println(err)
			return picturesBytes
		}
		picturesBytes = append(picturesBytes, picBytes)
	}
	return picturesBytes
}

func UploadPictures(mastoClient mastodon.Client, filesBytes [][]byte) []*mastodon.Attachment {
	var attachments []*mastodon.Attachment

	for _, file := range filesBytes {
		att, err := mastoClient.UploadMediaFromBytes(context.Background(), file)

		if err != nil {
			log.Println(err)
			return attachments
		}

		attachments = append(attachments, att)
	}

	return attachments
}

func CreateToot(mastoClient mastodon.Client, newsDesc *gofeed.Item) (mastodon.Toot, error) {
	var imgArray []string
	var attachments []*mastodon.Attachment

	var tootText string = fmt.Sprintf("src: %s\n\n", newsDesc.Link)

	toot := mastodon.Toot{
		Visibility: "unlisted",
		Sensitive:  true,
	}

	uString := html.UnescapeString(newsDesc.Description)
	pHtml, err := html.Parse(strings.NewReader(uString))
	if err != nil {
		return mastodon.Toot{}, err
	}

	for n := range pHtml.Descendants() {
		if n.Type != html.ElementNode {
			tootText += (n.Data)
		}

		if n.Type == html.ElementNode {
			switch n.Data {
			case "img":
				for _, attr := range n.Attr {
					if attr.Key == "src" {
						imgArray = append(imgArray, attr.Val)
					}
				}

			case "br":
				tootText += "\n"
			}
		}

	}

	if len(imgArray) != 0 {
		attachments = UploadPictures(mastoClient, PicBytesArray(imgArray))
	}

	toot.Status = tootText
	for _, attach := range attachments {
		toot.MediaIDs = append(toot.MediaIDs, attach.ID)
	}

	return toot, nil
}