Einführung

Ich lerne Go, aber wenn ich nach Informationen von mir selbst suche, ist das natürlich, aber ich kann nur die Informationen bekommen, die ich will. Ich denke, es ist notwendig, verschiedene Artikel zu lesen, um das Gesamtwissen zu erweitern, aber es ist ziemlich schwer. Also habe ich einen Twitter-Bot erstellt, der Artikel mit Qiitas Go-Tag twittert!

@BotQiita ↑ Folge mir.

die Architektur

Es ist eine Struktur, die Sie verstehen können, auch wenn Sie sie in Sätzen erklären, aber ich habe ein Architekturdiagramm erstellt.

Artikel mit Go-Tag mit Qiita-API abrufen --Authentifizierung & Tweet mit Twitter API --lambda ist in Go geschrieben und läuft regelmäßig stündlich auf Cloudwatch

Es ist genauso wie das.

Code

Zunächst von der Twitter-Authentifizierung. Ich habe https://github.com/ChimeraCoder/anaconda verwendet.

package auth

import (
    "os"

	"github.com/ChimeraCoder/anaconda"	
)

type Credentials struct {
	ConsumerKey       string
	ConsumerSecret    string
	AccessToken       string
	AccessTokenSecret string
}

// GetTwitterAPI gets twitter client
func GetTwitterAPI() *anaconda.TwitterApi {
	creds := Credentials{
		ConsumerKey:       os.Getenv("CONSUMER_KEY"),
		ConsumerSecret:    os.Getenv("CONSUMER_SECRET"),
		AccessToken:       os.Getenv("ACCESS_TOKEN"),
		AccessTokenSecret: os.Getenv("ACCESS_TOKEN_SECRET"),
	}

	anaconda.SetConsumerKey(creds.ConsumerKey)
	anaconda.SetConsumerSecret(creds.ConsumerSecret)
	api := anaconda.NewTwitterApi(creds.AccessToken, creds.AccessTokenSecret)

	return api
}

Klicken Sie dann auf die Qiita-API, um den Artikel zu erhalten. Klicken Sie hier, um die Qiita-API-Spezifikationen anzuzeigen → https://qiita.com/api/v2/docs#%E6%8A%95%E7%A8%BF

package qiita

import (
	"encoding/json"
	"errors"
	"io/ioutil"
	"net/http"
	"net/url"
	"time"
)

type Client struct {
	Endpoint  string
	CreatedAt string
	Tag       string
}

type Article struct {
	Title     string    `json:"title"`
	URL       string    `json:"url"`
	CreatedAt time.Time `json:"created_at"`
}

//URL erstellen
func createUrl(u *url.URL, c *Client) string {
	q := u.Query() //Generieren Sie den Kartentyp der Abfrageparameter
	q.Set("page", "1") //Abfrageparameter festlegen
	q.Set("per_page", "10")
	q.Set("query", "tag:"+c.Tag+" created:>="+c.CreatedAt)
	u.RawQuery = q.Encode() //Abfrageparameter codieren
	return u.String()
}

func (c *Client) GetQiitaArticles() (*[]Article, error) {
	e, err := url.Parse(c.Endpoint) //URL analysieren
	if err != nil {
		return nil, err
	}

	u := createUrl(e, c) //URL nach dem Festlegen der Abfrageparameter
	req, err := http.NewRequest(http.MethodGet, u, nil) //Methode, URL, Körper einstellen
	if err != nil {
		return nil, err
	}

	resp, err := http.DefaultClient.Do(req) //Ausstellung anfordern
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, errors.New(resp.Status)
	}

	body, err := ioutil.ReadAll(resp.Body) //Lesen Sie die Antwort
	if err != nil {
		return nil, err
	}

	var articles []Article
	if err := json.Unmarshal(body, &articles); err != nil {
		return nil, err
	}
	return &articles, nil
}

Referenz

[Einführung in Go] Parsen und Generieren von URLs mit dem Paket net / url

Schließlich ist es Haupt. Da die Lambda-Funktion jede Stunde ausgeführt wird, erhält sie jedes Mal die Zeit vor einer Stunde und twittert, wenn der erhaltene Artikel später ist.

package main

import (
	"fmt"
	"os"
	"time"

	"github.com/Le0tk0k/qiita-twitter-bot/auth"
	"github.com/Le0tk0k/qiita-twitter-bot/qiita"
	"github.com/aws/aws-lambda-go/lambda"
)

var tag = "go"

func post() {
	c := qiita.Client{
		Endpoint:  "https://qiita.com/api/v2/items",
		CreatedAt: time.Now().Format("2006-01-02"),
		Tag:       tag,
	}

	api := auth.GetTwitterAPI()
	articles, err := c.GetQiitaArticles()
	if err != nil {
		fmt.Fprintln(os.Stderr, "Error:", err)
		os.Exit(1)
	}

	t := time.Now().Add(time.Duration((-1) * time.Hour))

	for _, i := range *articles {
		if i.CreatedAt.After(t) {
			_, err = api.PostTweet(i.Title+"\n#golang\n"+i.URL, nil)
			if err != nil {
				fmt.Fprintln(os.Stderr, err)
				os.Exit(1)
			}
		}
	}
}

func main() {
	lambda.Start(post)
}

Das war's für den Code. Generieren Sie anschließend eine Zip-Datei mit dem folgenden Befehl und laden Sie sie in die Lambda-Funktion hoch.

$ GOOS=linux GOARCH=amd64 go build -o post
$ zip handler.zip ./post

Schließlich

Eigentlich war es das erste Mal für AWS, aber es war überraschend reibungslos! Ich möchte von nun an nach und nach lernen.

Bitte folgen Sie uns! @BotQiita

Ich habe einen Twitter-Bot mit Go x Qiita API x Lambda erstellt

Einführung

die Architektur

Code

Schließlich