Publicado el

Cómo hice un recordatorio para escribir una publicación de blog usando GitHub Action

Autores

Como crear un recordatorio para escribir una entrada de blog con GitHub Actions

Como escritor, entiendo la importancia de la consistencia al publicar contenido nuevo. Sin embargo, hay momentos en que la vida se interpone en el camino y puede ser difícil recordar escribir una nueva entrada de blog. Para ayudarme a mantenerme al día con mi calendario de publicación, creé un simple recordatorio usando GitHub Actions. En esta publicación, compartiré cómo hice este flujo de trabajo.

¿Qué es GitHub Action?

GitHub Actions es una poderosa herramienta que te permite automatizar tus flujos de trabajo. Puedes usarla para construir, probar e implementar tu código. También puedes usarla para realizar una amplia gama de otras tareas, como enviar notificaciones o programar recordatorios.

Cómo creé un recordatorio para escribir una entrada de blog

Para crear un recordatorio para escribir una entrada de blog, estoy usando el repositorio especial de GitHub README.md y agregué un archivo llamado .github/workflows/blog-posts.yml. En este archivo, definí el flujo de trabajo que ejecutaría GitHub Actions. Este es el contenido inicial del archivo:

name: Blog Posts

on:
  schedule:
    - cron: '0 0 * * 0' # Ejecutar a las 00:00 cada domingo
  workflow_dispatch:

jobs:
  update-posts:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Update post list
        run: |
          sleep 1m
          curl -LO https://blog.imam.dev/feed.xml
          node src/list-posts.js
          rm feed.xml
      - name: Commit changes
        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 "Update blog posts"
      - name: Pull changes
        run: git pull -r
      - name: Push changes
        uses: ad-m/github-push-action@0fafdd62b84042d49ec0cb92d9cac7f7ce4ec79e
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}

Este flujo de trabajo se activa cada domingo a las 00:00. Luego ejecuta un script que actualiza la lista de entradas de blog. El script está escrito en JavaScript y analiza el feed RSS de mi blog. Luego genera una lista de entradas de blog y actualiza el archivo README.md. Finalmente, confirma los cambios y los envía a GitHub. Estoy usando el repositorio de ouuan como referencia para este flujo de trabajo.

¿De dónde proviene el recordatorio? En realidad, está en el archivo list-posts.js. Agregué un recordatorio a la lista de entradas de blog. Este es el contenido del archivo:

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

/**
 * Convertir cadena XML a 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
}

// Leer archivo XML y convertir a JSON
const xmlString = readFileSync('feed.xml', 'utf8')
const feeds = sortJson(xmlToJson(xmlString).rss.channel.item)

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

// Actualizar README.md si las publicaciones han cambiado,
// De lo contrario, arrojar un error para recordarme que escriba una entrada de blog
const readme = readFileSync('README.md', 'utf8')
if (readme.includes(posts.join('\n'))) {
  throw new Error('No new blog posts')
} 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('Updated README.md')
}

El script lee el feed RSS de mi blog y genera una lista de entradas de blog. Luego actualiza el archivo README.md con la lista de entradas de blog. Si no hay nuevas entradas de blog, arroja un error para recordarme que escriba una entrada de blog.

Es solo un error que se lanzará cuando el script se ejecute mientras las publicaciones siguen siendo las mismas y no es un recordatorio que se enviará a mi correo electrónico o algo más visible para mí. Entonces, decidí habilitar la notificación para cualquier ejecución de flujo de trabajo fallida. Aquí se explica cómo hacerlo:

  1. Haz clic en la esquina superior derecha de la página y selecciona Configuración.

  2. Selecciona Notificaciones en la barra lateral izquierda.

  3. Haz clic en Acciones.

  4. Selecciona Enviar notificaciones solo para flujos de trabajo fallidos.

Ahora, recibiré una notificación cuando el script se ejecute y no haya nuevas entradas de blog. También puedo ver la notificación en el sitio web de GitHub.

Otra forma que exploré

El flujo de trabajo anterior que te cuento es una versión modificada para que mi README.md esté siempre actualizado. También exploré otra forma de crear un recordatorio para escribir una entrada de blog. Pero, es un recordatorio puro sin ningún mecanismo de actualización de README.md, solo un recordatorio.

Para crear un recordatorio para escribir una entrada de blog, creé un nuevo repositorio de GitHub y agregué un archivo llamado .github/workflows/remind.yml. En este archivo, definí el flujo de trabajo que ejecutaría GitHub Actions. Este es el contenido del archivo:

name: Reminder to write a blog post

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

jobs:
  remind:
    runs-on: ubuntu-latest
    steps:
      - name: Send a reminder
        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: 'Reminder to write a new blog post'
          body: "Don't forget to write a new blog post today!"
          to: my-email@example.com

Este flujo de trabajo me envía un recordatorio por correo electrónico todos los días de la semana a las 10:00 AM, recordándome que escriba una nueva entrada de blog. Usé una acción de terceros, dawidd6/action-send-mail, para enviar el correo electrónico. Proporcioné mis credenciales de correo electrónico como secretos de GitHub, por lo que no son visibles en el archivo del flujo de trabajo.

Conclusión

He explorado dos formas de crear un recordatorio para escribir una entrada de blog. La primera forma es actualizar el archivo README.md de mi perfil de GitHub. La segunda forma es enviar un recordatorio por correo electrónico. Actualmente estoy usando la primera forma porque es más visible que la segunda forma. Puedo ver el recordatorio cada vez que visito mi perfil de GitHub.

Crear un recordatorio para escribir una entrada de blog usando GitHub Actions es una forma simple y efectiva de mantenerte al día con tu calendario de publicación de blog. Con este flujo de trabajo en su lugar, nunca más olvidarás escribir una nueva publicación. Si estás interesado en crear tu propio flujo de trabajo de recordatorio, asegúrate de consultar la documentación de GitHub Actions para obtener más información. ¡Feliz blogueo!

Comentar en Twitter

COMPARTIR