Como criar uma notificação de publicação de postagem de blog usando GitHub Actions

Como Criar um Lembrete para Escrever um Post de Blog Usando GitHub Actions

Como escritor, entendo a importância da consistência quando se trata de publicar novos conteúdos. No entanto, existem momentos em que a vida atrapalha, e pode ser desafiador lembrar de escrever um novo post de blog. Para me ajudar a manter-me no ritmo do meu cronograma de compartilhamento, criei um lembrete simples usando GitHub Actions. Neste post, compartilharei como fiz essa automação.

O que é GitHub Actions?

GitHub Actions é uma ferramenta poderosa que permite automatizar seus fluxos de trabalho. Você pode usá-la para construir, testar e implantar seu código. Também pode usá-la para executar uma ampla gama de outras tarefas, como enviar notificações ou agendar lembretes.

Como Criei um Lembrete para Escrever um Post de Blog

Para criar um lembrete para escrever um post de blog, estou usando o repositório especial do GitHub do README.md e adicionei um arquivo chamado .github/workflows/blog-posts.yml. Neste arquivo, defini o fluxo de trabalho que o GitHub Actions executaria. Aqui está o conteúdo inicial do arquivo:

name: Blog Posts

on:
  schedule:
    - cron: '0 0 * * 0' # Executar às 00:00 todos os domingos
  workflow_dispatch:

jobs:
  update-posts:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Atualizar lista de posts
        run: |
          sleep 1m
          curl -LO https://blog.imam.dev/feed.xml
          node src/list-posts.js
          rm feed.xml
      - name: Confirmar alterações
        run: |
          git config --local user.email "github-actions[bot]@users.noreply.github.com"
          git config --local user.name "github-actions[bot]"
          git add -A
          git diff-index --quiet HEAD || git commit -m "Atualizar posts do blog"
      - name: Puxar alterações
        run: git pull -r
      - name: Empurrar alterações
        uses: ad-m/github-push-action@0fafdd62b84042d49ec0cb92d9cac7f7ce4ec79e
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}

Este fluxo de trabalho é acionado todos os domingos às 00:00. Ele então executa um script que atualiza a lista de posts de blog. O script é escrito em JavaScript e analisa o feed RSS do meu blog. Ele então gera uma lista de posts de blog e atualiza o arquivo README.md. Finalmente, ele confirma as alterações e as envia para o GitHub. Estou usando o repositório do ouuan como referência para este fluxo de trabalho.

De onde vem o lembrete? Na verdade, ele está no arquivo list-posts.js. Adicionei um lembrete à lista de posts de blog. Aqui está o conteúdo do arquivo:

const { readFileSync, writeFileSync } = require('fs')

/**
 * Converter string XML para JSON
 * @param {string} xmlString
 * @returns {object} json
 */
const xmlToJson = (xmlString) => {
  const regex = /<(\w+)([^>]*)>([\s\S]*?)<\/\1>/gm
  const matches = xmlString.matchAll(regex)
  const json = {}

  for (const match of matches) {
    const [, key, attributes, value] = match
    const subMatches = value.matchAll(regex)
    const subJson = {}

    for (const subMatch of subMatches) {
      const [, subKey, subAttributes, subValue] = subMatch

      if (subValue.match(regex)) {
        if (Array.isArray(subJson[subKey])) {
          subJson[subKey].push(
            xmlToJson(`<${subKey}${subAttributes}>${subValue}</${subKey}>`)[subKey]
          )
        } else if (subJson[subKey]) {
          subJson[subKey] = [
            subJson[subKey],
            xmlToJson(`<${subKey}${subAttributes}>${subValue}</${subKey}>`)[subKey],
          ]
        } else {
          subJson[subKey] = xmlToJson(`<${subKey}${subAttributes}>${subValue}</${subKey}>`)[subKey]
        }
      } else if (Array.isArray(subJson[subKey])) {
        subJson[subKey].push(subValue)
      } else if (subJson[subKey]) {
        subJson[subKey] = [subJson[subKey], subValue]
      } else {
        subJson[subKey] = subValue
      }
    }

    if (json[key]) {
      if (Array.isArray(json[key])) {
        json[key].push(subJson)
      } else {
        json[key] = [json[key], subJson]
      }
    } else {
      json[key] = subJson
    }
  }

  return json
}

/**
 * Ordenar JSON por pubDate
 * @param {object} json
 * @returns {object} sortedJson
 */
const sortJson = (json) => {
  json.sort((a, b) => new Date(b.pubDate) - new Date(a.pubDate))
  return json
}

// Ler arquivo XML e converter para JSON
const xmlString = readFileSync('feed.xml', 'utf8')
const feeds = sortJson(xmlToJson(xmlString).rss.channel.item)

// Criar lista Markdown de posts
const posts = feeds
  .slice(0, 5)
  .map(
    (item) =>
      `- ${new Date(item.pubDate).toISOString().split('T')[0]} [${item.title}](${
        item.link
      }?utm_source=GitHubProfile)`
  )

// Atualizar README.md se os posts foram alterados,
// Caso contrário, lançar um erro para me lembrar de escrever um post de blog
const readme = readFileSync('README.md', 'utf8')
if (readme.includes(posts.join('\n'))) {
  throw new Error('Nenhum novo post de blog')
} else {
  const updatedReadme = readFileSync('README.md', 'utf8').replace(
    /(?<=<!--START_SECTION:blog-posts-->\n)[\s\S]*(?=\n<!--END_SECTION:blog-posts-->)/,
    posts.join('\n')
  )
  writeFileSync('README.md', updatedReadme)

  console.log('README.md atualizado')
}

O script lê o feed RSS do meu blog e gera uma lista de posts de blog. Ele então atualiza o arquivo README.md com a lista de posts de blog. Se não houver novos posts de blog, ele lança um erro para me lembrar de escrever um post de blog.

É apenas um erro que será lançado quando o script for executado enquanto os posts ainda forem os mesmos, e não é um lembrete que será enviado para meu e-mail ou algo mais visível para mim. Portanto, decidi ativar a notificação para quaisquer execuções de fluxo de trabalho com falha. Aqui está como fazer isso:

Clique no canto superior direito da página e selecione Configurações.
Selecione Notificações na barra lateral esquerda.
Clique em Ações.
Selecione Enviar notificações apenas para fluxos de trabalho com falha.

Agora, receberei uma notificação quando o script for executado e não houver novos posts de blog. Também posso ver a notificação no site do GitHub.

Outra Maneira Que Explorei

O fluxo de trabalho anterior que lhe contei é uma versão modificada para que meu README.md esteja sempre atualizado. Também explorei outra maneira de criar um lembrete para escrever um post de blog. Mas, é um lembrete puro sem nenhum mecanismo de atualização README.md, apenas um lembrete.

Para criar um lembrete para escrever um post de blog, criei um novo repositório do GitHub e adicionei um arquivo chamado .github/workflows/remind.yml. Neste arquivo, defini o fluxo de trabalho que o GitHub Actions executaria. Aqui está o conteúdo do arquivo:

name: Lembrete para escrever um post de blog

on:
  schedule:
    - cron: '0 10 * * 1-5'

jobs:
  remind:
    runs-on: ubuntu-latest
    steps:
      - name: Enviar um lembrete
        uses: dawidd6/action-send-mail@v3.1.0
        with:
          server_address: smtp.gmail.com
          server_port: 465
          username: ${{ secrets.EMAIL_USERNAME }}
          password: ${{ secrets.EMAIL_PASSWORD }}
          subject: 'Lembrete para escrever um novo post de blog'
          body: "Não se esqueça de escrever um novo post de blog hoje!"
          to: meu-email@example.com

Este fluxo de trabalho me envia um lembrete por e-mail todos os dias úteis às 10h00, lembrando-me de escrever um novo post de blog. Usei uma ação de terceiros, dawidd6/action-send-mail, para enviar o e-mail. Forneci minhas credenciais de e-mail como segredos do GitHub, para que não sejam visíveis no arquivo de fluxo de trabalho.

Conclusão

Explorei duas maneiras de criar um lembrete para escrever um post de blog. A primeira maneira é atualizar o arquivo README.md do meu perfil do GitHub. A segunda maneira é enviar um lembrete por e-mail. Atualmente estou usando a primeira maneira porque é mais visível do que a segunda maneira. Posso ver o lembrete sempre que visito meu perfil do GitHub.

Criar um lembrete para escrever um post de blog usando GitHub Actions é uma maneira simples e eficaz de manter-se no ritmo do seu cronograma de blog. Com este fluxo de trabalho em vigor, você nunca mais esquecerá de escrever um novo post. Se você estiver interessado em criar seu próprio fluxo de trabalho de lembrete, certifique-se de verificar a documentação do GitHub Actions para saber mais. Feliz blogar!