introduction

J'étudie le Go, mais quand je cherche des informations de moi-même, c'est naturel, mais je ne peux obtenir que les informations que je veux. Je pense qu'il est nécessaire de lire divers articles afin d'élargir les connaissances générales, mais c'est assez lourd. J'ai donc créé un robot Twitter qui tweete des articles avec la balise Go de Qiita!

@BotQiita ↑ Suivez-moi.

architecture

C'est une structure que vous pouvez comprendre même si vous l'expliquez en phrases, mais j'ai fait un diagramme d'architecture.

Obtenez des articles avec la balise Go avec l'API Qiita --Authentifier et tweeter avec l'API Twitter --lambda est écrit en Go et fonctionne régulièrement sur cloudwatch toutes les heures

C'est comme ça.

code

Tout d'abord, à partir de l'authentification Twitter. J'ai utilisé https://github.com/ChimeraCoder/anaconda.

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
}

Ensuite, appuyez sur l'API Qiita pour obtenir l'article. Cliquez ici pour les spécifications de l'API Qiita → 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"`
}

//Créer une URL
func createUrl(u *url.URL, c *Client) string {
	q := u.Query() //Générer le type de carte des paramètres de requête
	q.Set("page", "1") //Définir les paramètres de requête
	q.Set("per_page", "10")
	q.Set("query", "tag:"+c.Tag+" created:>="+c.CreatedAt)
	u.RawQuery = q.Encode() //Encoder les paramètres de requête
	return u.String()
}

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

	u := createUrl(e, c) //URL après avoir défini les paramètres de requête
	req, err := http.NewRequest(http.MethodGet, u, nil) //Définir la méthode, l'url, le corps
	if err != nil {
		return nil, err
	}

	resp, err := http.DefaultClient.Do(req) //Demande d'émission
	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) //Lisez la réponse
	if err != nil {
		return nil, err
	}

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

référence

[Introduction to Go] Analyse et génération d'URL avec le package net / url

Enfin c'est principal. Étant donné que la fonction lambda est exécutée toutes les heures, elle obtient à chaque fois l'heure d'il y a une heure et tweete si l'article obtenu est postérieur à cela.

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)
}

Voilà pour le code. Après cela, générez un fichier zip avec la commande suivante et téléchargez-le dans la fonction lambda.

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

finalement

En fait, c'était la première fois pour AWS, mais c'était étonnamment fluide! Je veux étudier petit à petit à partir de maintenant.

Merci de nous suivre! @BotQiita

J'ai créé un bot Twitter avec Go x Qiita API x Lambda

introduction

architecture

code

finalement