DEV Community: Salustiano Muniz

Como eu transformei uma semana de trabalho em 30 segundos com PHP e Amazon Web Services SES

Salustiano Muniz — Sun, 25 Jan 2026 03:06:19 +0000

Recentemente, transformei um processo manual que consumia uma semana inteira de trabalho em uma ferramenta automatizada, eficiente e profissional. Além de resolver um problema real, este projeto serviu como um laboratório para aplicar conceitos avançados de arquitetura de software.

O Problema: O Caos do Processo Manual

Conversando com uma profissional da área de eventos, identifiquei um gargalo crítico: o envio de comunicados para listas de contatos. O fluxo de trabalho dela era:

Fragmentação: Copiar 300 e-mails por vez para o campo BCC do Gmail.
Limitação Técnica: Interromper o trabalho ao atingir a quota diária de envios.
Gestão de Erros Manual: Abrir e-mails de "bounce" (retorno) um a um, localizar o contato em uma planilha e excluí-lo manualmente.
Inconsistência: O uso de texto puro e a falta de padronização visual prejudicavam a identidade da marca.

Esse processo era moroso, sujeito a falhas e impedia o foco em tarefas estratégicas de divulgação.

A Análise e a Estratégia

A solução óbvia seria um serviço de e-mail marketing (como Mailchimp ou RD Station). No entanto, diante da ausência de orçamento para ferramentas pagas, decidi desenvolver uma solução personalizada que unisse baixo custo operacional com alta eficiência.

Os pilares do projeto seriam:

Automação: Envio em massa sem intervenção manual repetitiva.
Conformidade: Gestão automática de bounces e unsubscribes.
Profissionalismo: Templates HTML responsivos com Twig.
Escalabilidade: Integração com AWS SES (Simple Email Service).

Arquitetura: Clean Architecture e SOLID em Prática

Embora o escopo parecesse simples, utilizei o projeto para demonstrar domínio em arquitetura de software, garantindo que o código fosse testável, modular e de fácil manutenção.

1. Separação de Responsabilidades (Clean Architecture)

Dividi o projeto em camadas claras:

Domain: Onde residem as regras de negócio e interfaces, totalmente isolado de bibliotecas externas.
Infrastructure: Implementações concretas de serviços como AWS SES, leitura de CSVs e renderização de templates.
Command (Application): A porta de entrada via CLI, orquestrando os serviços de domínio.

2. Inversão de Dependência (DIP)

O EmailCampaignService não conhece os detalhes de como um e-mail é enviado ou de onde vem a lista de rejeitados. Ele depende de interfaces:

// Domínio dependendo de abstrações
public function __construct(
    private UnsubscriptionRepositoryInterface $unsubscriptionRepository,
    private RejectedRecipientRepositoryInterface $rejectedRecipientRepository,
    private EmailRenderer $emailRenderer,
    private SesEmailSender $emailSender,
    // ...
)

Isso permite, por exemplo, trocar o provedor de e-mail (de AWS SES para SendGrid) apenas alterando a implementação na camada de infraestrutura, sem tocar na lógica de negócio.

3. Domain-Driven Design (DDD)

Utilizei o conceito de Domain Services para concentrar a lógica da campanha e DTOs (EmailSendingDTO) para garantir que os dados trafeguem de forma tipada e segura entre as camadas.

Funcionalidades e Uso

O sistema é operado via CLI (Symfony Console), oferecendo dois comandos principais:

email:send: Inicia o disparo da campanha. Pode ser usado de modo interativo (prompts) ou parametrizado. Ele filtra automaticamente os e-mails contra listas de desinscrição e rejeitados antes do envio.
rejected:update: Sincroniza a lista local de e-mails rejeitados com a Suppression List da AWS, garantindo que a reputação do domínio seja preservada ao evitar reenvios para endereços inválidos.

Resultados e Conclusão

A automação reduziu o tempo de operação de dias para minutos. O uso de templates Twig trouxe uma estética profissional aos e-mails, enquanto a integração com a API da AWS garantiu a entrega em conformidade com as boas práticas de mercado.

Para mim, como desenvolvedor, o projeto foi uma oportunidade de materializar conceitos teóricos de SOLID e Clean Architecture em uma ferramenta prática, robusta e totalmente coberta por testes unitários (PHPUnit).

O código está disponível no meu GitHub como parte do meu portfólio de arquitetura. Use este link para acessá-lo.

Fiquem a vontade para comentar, sugerir ou mesmo utilizar o projeto como base para suas próprias soluções

Criando uma página pessoal com a API do dev.to e VueJS

Salustiano Muniz — Fri, 02 Sep 2022 05:00:36 +0000

Estava há muito tempo querendo fazer uma página pessoal pra usar de portifólio e também como blog de tecnologia, e depois de estudar várias soluções, descobri que o dev.to tem uma API que possibilita a consulta dos dados do usuário assim como seus artigos. Com isso na mão, me animei a fazer uma aplicação em Vue que lesse esses dados

A API

Inicialmente cheguei neste artigo que demonstrava como consumir a API da plataforma, com exemplo em PHP.

How to use the dev.to API!

𝐍𝐚𝐭𝐚𝐥𝐢𝐞 𝐝𝐞 𝐖𝐞𝐞𝐫𝐝 ・ Jun 7 '20 ・ 2 min read

#beginners #webdev #php #tutorial

No artigo, tem um link para um outro que mostra vários endpoints que você pode consultar pra obter os dados que deseja. Pesquisando um pouco mais, cheguei à documentação oficial.

DEV API (beta) | Forem Docs

Access Forem articles, users and other resources via API. For a real-world example of Forem in action, check out [DEV](https://www.dev.to). All endpoints that don't require authentication are CORS enabled. All requests must send a user-agent header. Dates and date times, unless otherwise specified, must be in the [RFC 3339](https://tools.ietf.org/html/rfc3339) format.

developers.forem.com

E com isso, cheguei nos 2 endpoints que precisava:

Vue

Tendo a API e os endpoints, o próximo passo foi buscar esses dados dentro do site, pra depois exibir do jeito que eu queria.

Consumindo a API

O primeiro passo foi criar um método pra centralizar as requisições à api, que fiz com axios

import axios, {AxiosInstance} from "axios";

 const http: AxiosInstance = axios.create({
    baseURL: "https://dev.to/api/",
    headers: {
        'Accept': "application/json",
        'Content-Type': 'application/json'
    }
})

export default http;

Depois disso, criei serviços distindos para fazer a consulta aos endpoints.

O service pra receber artigos:

import http from "@/http";

export const getArticles = () => http.get('articles', {
    params: {
        username: 'stsmuniz'
    }
})

E o service para receber o perfil

import http from "@/http";

export const getProfile = () => http.get('users/by_username', {
    params: {
        url: 'stsmuniz'
    }
})

Com os services criados, agora podemos usar no site

Exibindo o perfil

Antes de mais nada, é necessário fazer a consulta efetivamente. Como usei composition api, usei o método onBeforeMount pra buscar os dados antes de renderizar a página.

  setup() {
    const profile = ref()

    onBeforeMount(() => {
      getProfile()
          .then(res => profile.value = res.data)
    })
    ....
    return {
        profile
    }
})

E na página vai o componente que "monta" o perfil

    <ProfileComponent profile="profile" v-if="profile"/>
    <i class="fa-solid fa-spinner fa-spin-pulse" v-else></i>

O ProfileComponent é o componente que recebe as informações do perfil e "monta" o perfil na tela.

<template>
  <div class="profile">
    <img class="profile-picture" :alt="profile.username" :src="profile.profile_image">
    <h1>{{profile.name}}</h1>
    <p class="description" v-html="profile.summary.replace('\n', '<br />')"></p>
    <p><i class="fa-solid fa-location-dot"></i> {{profile.location}}</p>
  </div>
</template>

<script lang="ts">
import {defineComponent} from "vue";

export default defineComponent({
  name: "ProfileComponent",
  props: {
    profile: {
      required: true
    }
  },
})
</script>

E com isso conseguimos fazer o perfil ser renderizado na tela. O próximo passo é fazer o mesmo processo para os artigos

Exibindo os artigos

A primeira coisa aqui é criar a view para exibir os artigos, que chamei aqui de Blog. No setup há a chamada para a API pelo service ArticleService, com o

<template>
  <div class="home" v-if="articles">
    <h1>Blog</h1>
    <ArticleList :articles="articles"/>
  </div>
  <i class="fa-solid fa-spinner fa-spin-pulse" v-else></i>
</template>

<script lang="ts">
import {defineComponent, onMounted, ref} from 'vue';
import {getArticles} from "@/service/ArticleService";

import ArticleList from '@/components/ArticleList.vue';

export default defineComponent({
  name: 'BlogView',
  components: {
    ArticleList,
  },
  setup() {
    const articles = ref()

    onMounted(() => {
      document.title = 'Blog'
    })

    getArticles()
        .then(res => articles.value = res.data)

    return {
      articles
    }
  }
});
</script>

O ArticleList é um componente container que, basicamente, organiza o container pra lista de artigos

<template>
  <div class="container">
    <ArticleItem v-for="article in articles" :article="article" :key="article.id" />
  </div>
</template>

<script>
import {defineComponent} from 'vue';
import ArticleItem from "@/components/ArticleItem";

export default defineComponent({
  name: 'ArticleList',
  components: {ArticleItem},
  props: {
    articles: {
      required: true
    }
  }
});
</script>

E por fim, o componente ArticleItem organiza as informações no template pra fazer a exibição

<template>
  <article>
    <a :href="article.url"
       :title="article.title"
       target="_blank">
      <img class="responsive"
           :src="article.cover_image"
           :alt="article.title" />
    </a>
    <div class="article-data">
      <h1>
        <a :href="article.url"
           :title="article.title"
           target="_blank">
          {{ article.title }}
        </a>
      </h1>
      <p class="article-description">{{article.description}}</p>
      <p class="publish-date">
        <i class="fa-solid fa-calendar"></i> <DateFormatter :date="article.published_at" />
      </p>
    </div>
  </article>
</template>

<script>
import DateFormatter from "./DateFormatter";
import {defineComponent} from "vue";

export default defineComponent({
  name: "ArticleItem",
  components: {DateFormatter},
  props: {
    article: {
      required: true
    }
  }
})
</script>

Como eu queria exibir a data no formato dd/mm/yyyy, criei o componente DateFormatter pra tratar a string que vem no formato ISO.

Deploy

Dei uma fuçada e acabei encontrando um artigo interessante que explica bem como fazer o deploy:

Automatically build and deploy a Vue.js app with GitHub Pages - LogRocket Blog

Learn how to automatically build and deploy a Vue.js project to GitHub Pages, a static site hosting service for your GitHub projects.

blog.logrocket.com

Se você for usar esse método, tome cuidado com o nome da branch principal no arquivo gh-pages-deploy.js. No artigo ela está sendo chamada como master.

Fechando

Com isso, mais a estrutura básica do vue e alguma estilização, pode se ter um site simples com informações básicas vindas do seu perfil do dev.to e uma página com link para seus artigos mais recentes.

Pretendo criar um repositório aberto pra compartilhar o que fiz aqui e deixar fácil pra qualquer pessoa com perfil aqui também ter sua página pessoal, assim como a minha

Obrigado por acompanhar até aqui e nos vemos na próxima 👋

Exportando dados em planilhas no Laravel e Livewire sem sujeira e sem raizes brancas

Salustiano Muniz — Wed, 15 Sep 2021 00:48:17 +0000

Esses dias eu tive que criar "só um botãozinho" que exportasse os dados filtrados pelo usuário na página e exportasse para uma planilha para ser aberta no Excel. E depois de uma boa pesquisa, encontrei o pacote Laravel Excel, que facilita muito o trabalho. Neste artigo quero compartilhar minha experiência na implementação, pois apesar de o pacote ter documentação com exemplos, tive um pouco de trabalho pra juntar tudo e fazer funcionar da forma que eu precisava.

Antes de começar

O projeto que estou trabalhando usa Livewire rodando em Laravel 8 e PHP 8.0 e por isso os exemplos de código contidos no artigo usarão estas tecnologias, mas o pacote não depende do Livewire, podendo ser usado com Laravel a partir da versão 5.8, e com versões do PHP a partir da versão 7.2.

Configuração

Instalando o pacote

O primeiro passo é instalar o pacote através do composer.

composer require maatwebsite/excel

Criando a classe de exportação

Com o pacote instalado, o próximo passo é criar a classe exportadora, que vai cuidar de configurar o arquivo a ser exportado. O comando que cria a classe de exportação aceita o parâmetro --model, usado para informar o Model de onde sairão as informações.

php artisan make:export TransactionExport --model=AccountTransaction

A classe gerada pelo comando do artisan terá a seguinte estrutura:

 <?php

namespace App\Exports;  

use App\Models\AccountTransaction;  
use Maatwebsite\Excel\Concerns\FromCollection;  

class TransactionExport implements FromCollection  
{  
    public function collection()
    {
        return AccountTransaction::all();
    }

}

Utilização

Passando dados para a exportação

Por padrão, a classe de exportação seleciona todos os registros do Model para exportar, mas é possível passar outra fonte de dados, que pode ser uma Collection ou um array através do método mágico __constructor da classe. No exemplo abaixo, é feito com uma collection

public function __construct(
    public Collection $transactions
) {
}

public function collection(): Collection
{
    return $this->transactions;
}

Adicionando o cabeçalho

Apesar de neste ponto já ser possível baixar o arquivo, ele ainda não vai ter cabeçalho, mas o pacote permite adicionar cabeçalho ao arquivo utilizando a interface do pacote Laravel Excel WithHeadings à chamada da classe:

class TransactionExport implements FromCollection, WithHeadings
{

Depois disso, precisamos passar os dados do cabeçalho no __constructor através de um array

public function __construct(
    public Collection $transactions,
    public array $headings  
) {  
}

Eu optei por usar os nomes das colunas como estão no banco de dados no cabeçalho e porque poderia reaproveitar esta informação para selecionar as colunas no método de exportação

$columns  =  [
    'description',
    'financial_category_id',
    'transaction_status_id',
    'accrual_month',
    'due_date',
    'value',
    'document_number',
    'notes',
    'financial_account_id',
    'supplier_id',
    'cost_center_id',
    'payment_date',
    'final_value',
    'payment_method_id'
];

Mas como estes nomes de colunas não seriam bons, criei entradas respectivas no arquivo de tradução resources\lang\pt_BR\dashboard.php:

return [
    ...
    'account_transaction' => [  
        'description' => 'Descrição',  
        'financial_category_id' => 'Categoria Financeira',  
        'transaction_status_id' => 'Status da Transação',  
        'accrual_month' => 'Mês de Vigência',  
        'due_date' => 'Data de Vencimento',  
        'value' => 'Valor',  
        'document_number' => 'Número do Documento',  
        'notes' => 'Observações',  
        'financial_account_id' => 'Conta Financeira',  
        'supplier_id' => 'Fornecedor',  
        'cost_center_id' => 'Centro de Custo',  
        'payment_date' => 'Data do Pagamento',  
        'final_value' => 'Valor Recebido',  
        'payment_method_id' => 'Forma de Pagamento'
    ]
];

E usando o método headings da interface do pacote Laravel Excel WithHeadings, usei a função array_map para fazer com que o array de nomes do cabeçalho fosse traduzido:

public function headings(): array  
{ 
    return array_map(  
        fn($columnName) => __('dashboard.account_transaction.'.$columnName),  
        $this->headings  
    );  
}

Personalizando a planilha

Nosso trabalho está quase completo, mas tanto os dados quanto a aparência da planilha podem ser melhor exibidos, e é isso que faremos a seguir.

Formatando dados

Os vêm do jeito que estão no banco de dados, ou seja, com os IDs das propriedades que têm relacionamento e as datas "cruas", mas podemos formatar estes dados com as interfaces do pacote Laravel Excel ColumnFormatting e WithMapping

class TransactionExport implements
    FromCollection,  
    WithColumnFormatting,  
    WithMapping,  
    WithHeadings
{

E implementamos seus métodos. Começando pelo map, para ordenar e substituir os IDs pelos respectivos nomes das entidades relacionadas com as colunas:

use PhpOffice\PhpSpreadsheet\Shared\Date;

...

public function map($row): array  
{  
  return [  
  $row->description,  
  $row->financialCategory->name,  
  $row->transactionStatus->name,  
  Date::dateTimeToExcel($row->accrual_month),  
  Date::dateTimeToExcel($row->due_date),  
  $row->value,  
  $row->document_number,  
  $row->notes,  
  $row->financialAccount->name,  
  $row->supplier->name,  
  $row->costCenter?->name,  
  $row->payment_date ? Date::dateTimeToExcel($row->payment_date) : null,  
  $row->final_value,  
  $row->paymentMethod?->name,  
  ];  
}

A classe PhpOffice\PhpSpreadsheet\Shared\Date é um "bônus" que o pacote Laravel Excel nos dá para facilitar a manipulação de dados. Como o pacote tem dependência com o PhpSpreadsheet, podemos usar métodos deste pacote.

O segundo passo para ajustar as linhas da planilha é resolvida pelo método columnFormats, que ficará assim:

use PhpOffice\PhpSpreadsheet\Style\NumberFormat;

...

public function columnFormats(): array  
{
    return [  
        'D' => 'mm/yyyy',  
        'E' => NumberFormat::FORMAT_DATE_DDMMYYYY,  
        'F' => NumberFormat::FORMAT_CURRENCY_USD_SIMPLE,  
        'L' => NumberFormat::FORMAT_DATE_DDMMYYYY,  
        'M' => NumberFormat::FORMAT_CURRENCY_USD_SIMPLE,  
    ];  
}

Como é visto no código de exemplo, o array deve ser composto pela letra que corresponde à coluna que precisamos formatar e uma máscara com a regra de formatação. Aqui mais uma vez usamos um método do pacote PhpSpreadsheet. Neste caso, o PhpOffice\PhpSpreadsheet\Style\NumberFormat, que tem inúmeras máscaras para formatação, mas você pode usar uma personalizada, assim como eu fiz na primeira entrada do array retornado pelo método.

Estilizando o cabeçalho

Agora só falta destacar o cabeçalho para que nossa planilha fique pronta para ser exportada e lida. E o Laravel Excel tem uma Interface para nos ajudar: WithStyles:

class TransactionExport implements  
    FromCollection,  
    WithColumnFormatting,  
    WithMapping,  
    WithHeadings,  
    WithStyles
{

Com a interface adicionada, hora de implementar o método styles:

use PhpOffice\PhpSpreadsheet\Style\Fill;

...

public function styles(Worksheet $sheet)  
{  
  $sheet->getStyle('A1:N1')
        ->getFill()  
        ->setFillType(Fill::FILL_SOLID)  
        ->getStartColor()  
        ->setRGB('51d2b7');  

  $sheet->getStyle('A1:N1')  
        ->getFont()  
        ->setBold(true)  
        ->getColor()  
        ->setRGB('ffffff');  
}

Aqui, a primeira declaração é responsável por estilizar a cor de fundo do cabeçalho, e a segunda é responsável por formatar a fonte, deixando o cabeçalho com o fundo verde e a fonte em negrito e branca. Além destes atributos, também é possível mudar outros como borda, alinhamento, etc. Os métodos e parâmetros obedecem os padrões da documentação de formatação do PhpSpreadsheet

Pra arrematar, indico usar a interface ShouldAutoSize, que ajusta o tamanho das colunas automagicamente.

class TransactionExport implements  
    FromCollection,  
    WithColumnFormatting,  
    WithMapping,  
    WithHeadings,  
    WithStyles,  
    ShouldAutoSize  
{

Classe de exportação

No final, a classe de exportação ficará assim:

<?php

namespace App\Exports;

use App\Models\AccountTransaction;
use Illuminate\Support\Collection;
use Maatwebsite\Excel\Concerns\FromCollection;
use Maatwebsite\Excel\Concerns\ShouldAutoSize;
use Maatwebsite\Excel\Concerns\WithColumnFormatting;
use Maatwebsite\Excel\Concerns\WithHeadings;
use Maatwebsite\Excel\Concerns\WithMapping;
use Maatwebsite\Excel\Concerns\WithStyles;
use PhpOffice\PhpSpreadsheet\Shared\Date;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;

class TransactionExport implements
    FromCollection,
    WithColumnFormatting,
    WithMapping,
    WithHeadings,
    WithStyles,
    ShouldAutoSize
{
    public function __construct(
        public Collection $transactions, public array $headings
    ) {
    }

    public function collection()
    {
        return $this->transactions;
    }

    public function columnFormats(): array
    {
        return [
            'D' => 'mm/yyyy',
            'E' => NumberFormat::FORMAT_DATE_DDMMYYYY,
            'F' => NumberFormat::FORMAT_CURRENCY_USD_SIMPLE,
            'L' => NumberFormat::FORMAT_DATE_DDMMYYYY,
            'M' => NumberFormat::FORMAT_CURRENCY_USD_SIMPLE,
        ];
    }

    public function map($row): array
    {
        return [
            $row->description,
            $row->financialCategory->name,
            $row->transactionStatus->name,
            Date::dateTimeToExcel($row->accrual_month),
            Date::dateTimeToExcel($row->due_date),
            $row->value,
            $row->document_number,
            $row->notes,
            $row->financialAccount->name,
            $row->supplier->name,
            $row->costCenter?->name,
            $row->payment_date ? Date::dateTimeToExcel($row->payment_date) : null,
            $row->final_value,
            $row->paymentMethod?->name,
        ];
    }

    public function headings() : array
    {
        return array_map(
            fn($columnName) => __('dashboard.account_transaction.' . $columnName),
            $this->headings
        );
    }

    public function styles(Worksheet $sheet)
    {
        $sheet->getStyle('A1:N1')
            ->getFill()
            ->setFillType(Fill::FILL_SOLID)
            ->getStartColor()
            ->setRGB('51d2b7');

        $sheet->getStyle('A1:N1')
            ->getFont()
            ->setBold(true)
            ->getColor()
            ->setRGB('ffffff');
    }
}

Criando o método de exportação

A partir daqui, nossa classe está pronta para receber, formatar e exportar nossos dados em uma planilha, que faremos através do Livewire com o método runQueryBuilder, o mesmo que busca os dados para exibir na página, com a diferença de que na chamada da página, ela é terminada com o método paginate para enviar dados paginados.


public function runQueryBuilder()  
{
    return $this->client  
        ->accountTransactions()  
        ->when(
            $this->transactionType,  
            fn($q) => $q->where('transaction_type', $this->transactionType)  
        )
        ->when(  
            $this->financialAccount,  
            fn($q) => $q->where('financial_account_id', $this->financialAccount)  
        )
        ->when(  
            $this->timePeriod,  
            fn($q) => $q->whereDate('due_date', '>=', $this->initialDueDate)
                        ->whereDate('due_date', '<=', $this->finalDueDate);
        )
        ->orderBy('due_date');  
}

E finalmente o método de exportar, que recebe os dados e chama o método estático download da facade Maatwebsite\Excel\Facades\Excel para criar e baixar a planilha.

public function export(): BinaryFileDownload
{
    $columns = [  
        'description',  
        'financial_category_id',  
        'transaction_status_id',  
        'accrual_month',
        'due_date',  
        'value',  
        'document_number',  
        'notes',  
        'financial_account_id',  
        'supplier_id',  
        'cost_center_id',  
        'payment_date',  
        'final_value',  
        'payment_method_id'  
    ];  

    $data = $this->runQueryBuilder()->get($columns);  
    $filename = 'transactions_'
        . strtolower(TransactionTypeEnum::search($this->transactionType))
        .'_'. date('Ymd_his') .'.xls';

    return Excel::download(
        new TransactionExport($data, $columns),
        $filename
    );  
}

Criando o botão de download

Com todo o código do backend criado, agora resta criar o botão que disparará a ação:

<button
    wire:click="export"
    wire:loading.attr="disabled"
    class="btn btn-primary btn-block text-uppercase">  
    <b>{{__('dashboard.Export')}}</b>
</button>

Resultado

E finalmente temos nosso "só um botãozinho". Ao clicar no botão de exportar, o download será iniciado em instantes e você terá um arquivo em formato XLS, que ao ser aberto em um programa de edição de planilhas - no meu caso, usei o Google Spreadsheets - será exibido assim:

Você também tem a opção de exportar o arquivo em outros formatos, mas lembre-se que alguuns deles não usa estilização, portanto parte deste trabalho será desnecessário.

E atenção, se liga aí que é hora da revisão

Na tele-aula de hoje, vimos que o pacote Laravel Excel pode ser usado para facilitar o processo de exportação de dados em forma de planilhas. Vimos também algumas formas de manipular estes dados e estilizar a planilha para melhorar sua leitura e apresentação. Por fim, implementamos tudo em um componente Livewire que nos permitiu fazer uso dos métodos desenvolvidos com um clique, baixamos o arquivo e visualizamos este em um editor de planilhas.

Este artigo foi uma forma de compartilhar minha experiência com o Laravel Excel, que me ajudou a facilitar um processo que tenho certeza que não sou só eu que vejo como complexo. A documentação do pacote tem várias outras opções de configuração de exportação de arquivos que podem ser exploradas, mas me concentrei em demonstrar as que usei. Recomendo a quem se interessar que dê uma lida e teste os exemplos.

Por hoje é isso. Nos vemos na próxima. Até lá e bons estudos.