PHPackages                             ferreiramg/notify-manager - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Mail & Notifications](/categories/mail)
4. /
5. ferreiramg/notify-manager

ActiveLibrary[Mail & Notifications](/categories/mail)

ferreiramg/notify-manager
=========================

Laravel plugin for notification management with dispatch rules, logging, and monetization

v1.3.0(9mo ago)024MITPHPPHP ^8.3CI passing

Since Aug 27Pushed 8mo agoCompare

[ Source](https://github.com/Ferreiramg/notify-manager)[ Packagist](https://packagist.org/packages/ferreiramg/notify-manager)[ Docs](https://github.com/Ferreiramg/notify-manager)[ GitHub Sponsors](https://github.com/Ferreiramg)[ RSS](/packages/ferreiramg-notify-manager/feed)WikiDiscussions main Synced today

READMEChangelog (3)Dependencies (9)Versions (8)Used By (0)

NotifyManager
=============

[](#notifymanager)

[![Tests](https://github.com/Ferreiramg/notify-manager/workflows/Tests/badge.svg)](https://github.com/Ferreiramg/notify-manager/actions)[![Latest Stable Version](https://camo.githubusercontent.com/6236b51540c88ed26368bb77992c093d50219c448b39560435154b1c9bca4b5a/68747470733a2f2f706f7365722e707567782e6f72672f66657272656972616d672f6e6f746966792d6d616e616765722f762f737461626c65)](https://packagist.org/packages/ferreiramg/notify-manager)[![Total Downloads](https://camo.githubusercontent.com/c972ee5d0a4781d4cb85d695545922ad35b4f6dd37f20214a7a89898d7d546d4/68747470733a2f2f706f7365722e707567782e6f72672f66657272656972616d672f6e6f746966792d6d616e616765722f646f776e6c6f616473)](https://packagist.org/packages/ferreiramg/notify-manager)[![License](https://camo.githubusercontent.com/591b56e4240490a3093b4e5725779380c70c417e64c3ab330d2b7137edfd528a/68747470733a2f2f706f7365722e707567782e6f72672f66657272656972616d672f6e6f746966792d6d616e616765722f6c6963656e7365)](https://packagist.org/packages/ferreiramg/notify-manager)[![PHP Version](https://camo.githubusercontent.com/2868bc9628e3ce5669f9df49cfe568dc0c39b2f595c2d1c602c0b200a2452364/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f7068702d382e332b2d626c75652e737667)](https://camo.githubusercontent.com/2868bc9628e3ce5669f9df49cfe568dc0c39b2f595c2d1c602c0b200a2452364/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f7068702d382e332b2d626c75652e737667)[![Laravel Version](https://camo.githubusercontent.com/2d53d2a361313eb34c21858f3cdaf291564d2b217a28cd79f130f5eab3ce3d4d/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c61726176656c2d31312e302b2d7265642e737667)](https://camo.githubusercontent.com/2d53d2a361313eb34c21858f3cdaf291564d2b217a28cd79f130f5eab3ce3d4d/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c61726176656c2d31312e302b2d7265642e737667)

> 📖 **[English Documentation](README-EN.md)** | **[Documentação em Português](README.md)**

Um poderoso pacote Laravel para gerenciar notificações com regras de envio, logs e recursos de monetização.

Recursos
--------

[](#recursos)

- 🚀 **Suporte Multi-Canal**: Envie notificações através de Email, Telegram, Slack, WhatsApp e canais personalizados
- 📋 **Envio Baseado em Regras**: Configure regras sofisticadas para controlar quando e como as notificações são enviadas
- ✨ **Mensagens Personalizadas**: Use metadados das regras para criar mensagens personalizadas com placeholders dinâmicos
- 📅 **Regras D+N e D-N**: Crie regras baseadas em datas relativas (D+3 para futuro, D-7 para passado) com mensagens específicas
- 🎨 **Sistema de Templates**: Use templates Blade para personalizar mensagens com cache automático
- ⚡ **Processamento Assíncrono**: Envie notificações via fila com suporte a agendamento
- 📊 **Log Abrangente**: Rastreie todas as atividades de notificação com logs detalhados
- 💰 **Monetização**: Rastreamento de custos integrado com multiplicadores de prioridade e comprimento
- 🔒 **PHP Moderno**: Construído com recursos do PHP 8.3+ incluindo classes readonly, enums e sintaxe moderna
- 🧪 **Bem Testado**: Suíte de testes abrangente (73.8% cobertura) usando Pest PHP
- � **Qualidade de Código**: Aplicado com estilo de código Laravel Pint

Instalação
----------

[](#instalação)

Instale o pacote via Composer:

```
composer require ferreiramg/notify-manager
```

Execute o comando de instalação:

```
php artisan notify-manager:install
```

Isso irá:

- Publicar o arquivo de configuração
- Publicar as migrações do banco de dados
- Executar as migrações (opcional)

Configuração
------------

[](#configuração)

### Configuração Básica

[](#configuração-básica)

O arquivo de configuração será publicado em `config/notify-manager.php`. Aqui você pode configurar:

```
return [
    'default_channel' => 'email',

    'channels' => [
        'email' => \App\NotificationChannels\EmailChannel::class,
        'telegram' => \App\NotificationChannels\TelegramChannel::class,
    ],

    'monetization' => [
        'enabled' => true,
        'currency' => 'USD',
        'default_cost_per_message' => 0.01,
        'priority_multipliers' => [
            1 => 1.0,   // Prioridade baixa
            2 => 1.5,   // Prioridade normal
            3 => 2.0,   // Prioridade alta
        ],
        'length_multiplier_threshold' => 160, // Caracteres
        'length_multiplier' => 1.2, // 20% extra para mensagens longas
    ],

    'queue' => [
        'enabled' => false,
        'connection' => 'default',
        'queue_name' => 'notifications',
    ],

    'templates' => [
        'path' => resource_path('views/notifications'),
        'cache_enabled' => true,
        'cache_ttl' => 3600, // 1 hora
    ],

    'logging' => [
        'enabled' => true,
        'retention_days' => 90,
    ],
];
```

### Variáveis de Ambiente

[](#variáveis-de-ambiente)

Adicione estas ao seu arquivo `.env`:

```
NOTIFY_MANAGER_DEFAULT_CHANNEL=email
NOTIFY_MANAGER_MONETIZATION_ENABLED=true
NOTIFY_MANAGER_LOGGING_ENABLED=true
NOTIFY_MANAGER_MAX_PER_HOUR=100
NOTIFY_MANAGER_MAX_PER_DAY=1000

# Queue Configuration
NOTIFY_MANAGER_QUEUE_ENABLED=false
NOTIFY_MANAGER_QUEUE_CONNECTION=redis
NOTIFY_MANAGER_QUEUE_NAME=notifications

# Template Configuration
NOTIFY_MANAGER_TEMPLATE_CACHE=true
NOTIFY_MANAGER_TEMPLATE_CACHE_TTL=3600
```

Uso
---

[](#uso)

### Envio Básico de Notificação

[](#envio-básico-de-notificação)

```
use NotifyManager\Facades\NotifyManager;
use NotifyManager\DTOs\NotificationDTO;

// Criar uma notificação
$notification = NotificationDTO::create(
    channel: 'email',
    recipient: 'user@example.com',
    message: 'Olá, esta é uma notificação de teste!',
    options: [
        'subject' => 'Notificação de Teste',
        'priority' => 1,
        'tags' => ['boas-vindas', 'onboarding-usuario']
    ]
);

// Enviar a notificação
$sent = NotifyManager::send($notification);

if ($sent) {
    echo "Notificação enviada com sucesso!";
} else {
    echo "Falha ao enviar notificação.";
}
```

### Criando Regras de Notificação

[](#criando-regras-de-notificação)

```
use NotifyManager\DTOs\NotificationRuleDTO;

$rule = NotificationRuleDTO::create(
    name: 'Limite Email Boas-vindas',
    channel: 'email',
    conditions: [
        [
            'field' => 'tags',
            'operator' => 'contains',
            'value' => 'boas-vindas'
        ]
    ],
    options: [
        'max_sends_per_day' => 1,
        'allowed_hours' => [9, 10, 11, 14, 15, 16, 17],
        'is_active' => true
    ]
);

NotifyManager::createRule($rule);
```

### Implementando Canais Personalizados

[](#implementando-canais-personalizados)

Crie um canal de notificação personalizado implementando a `NotificationChannelInterface`:

```
use NotifyManager\Contracts\NotificationChannelInterface;
use NotifyManager\DTOs\NotificationDTO;

class SlackChannel implements NotificationChannelInterface
{
    public function send(NotificationDTO $notification): bool
    {
        // Implementar integração com API do Slack
        $response = Http::post('https://hooks.slack.com/webhook-url', [
            'text' => $notification->message,
            'channel' => $notification->recipient,
        ]);

        return $response->successful();
    }

    public function getName(): string
    {
        return 'slack';
    }

    public function supports(NotificationDTO $notification): bool
    {
        return $notification->channel === 'slack';
    }

    public function getCostPerMessage(): float
    {
        return 0.001; // $0.001 por mensagem
    }

    public function validate(NotificationDTO $notification): bool
    {
        return !empty($notification->recipient) &&
               !empty($notification->message) &&
               str_starts_with($notification->recipient, '#');
    }
}
```

### Sistema de Templates

[](#sistema-de-templates)

O NotifyManager suporta templates Blade para personalizar suas mensagens:

#### Criando Templates

[](#criando-templates)

Crie templates em `resources/views/notifications/`:

```
{{-- resources/views/notifications/welcome.blade.php --}}
Bem-vindo, {{ $name }}!
Obrigado por se juntar à {{ $company }}.
Sua conta foi criada com sucesso em {{ $notification->created_at }}.

@if(isset($special_offer))

        Oferta Especial!
        {{ $special_offer }}

@endif
```

#### Usando Templates

[](#usando-templates)

```
$notification = NotificationDTO::create(
    channel: 'email',
    recipient: 'user@example.com',
    message: 'Mensagem de fallback se o template falhar',
    options: [
        'subject' => 'Bem-vindo!',
        'template' => 'welcome',
        'template_data' => [
            'name' => 'João Silva',
            'company' => 'Minha Empresa',
            'special_offer' => 'Desconto de 20% na primeira compra!'
        ]
    ]
);

NotifyManager::send($notification);
```

#### Configuração de Templates

[](#configuração-de-templates)

```
// config/notify-manager.php
'templates' => [
    'path' => resource_path('views/notifications'),
    'cache_enabled' => true,
    'cache_ttl' => 3600, // 1 hora
],
```

### Processamento Assíncrono (Queue)

[](#processamento-assíncrono-queue)

Envie notificações de forma assíncrona usando o sistema de filas do Laravel:

#### Configuração da Fila

[](#configuração-da-fila)

```
// config/notify-manager.php
'queue' => [
    'enabled' => true,
    'connection' => 'redis', // ou 'database', 'sqs', etc.
    'queue_name' => 'notifications',
],
```

#### Enviando Notificações Assíncronas

[](#enviando-notificações-assíncronas)

```
// Envio imediato na fila
NotifyManager::sendAsync($notification);

// Envio com delay de 5 minutos
NotifyManager::sendAsync($notification, 300);

// Envio agendado para 2 horas no futuro
NotifyManager::sendAt($notification, now()->addHours(2));

// Envio agendado para data específica
NotifyManager::sendAt($notification, Carbon::parse('2024-12-25 09:00:00'));
```

#### Processando a Fila

[](#processando-a-fila)

```
# Executar worker da fila
php artisan queue:work --queue=notifications

# Ou usar Supervisor para produção
php artisan queue:work --queue=notifications --daemon
```

### Registrando Canais Personalizados

[](#registrando-canais-personalizados)

Registre seu canal personalizado no service provider:

```
// No seu AppServiceProvider ou service provider personalizado
public function boot()
{
    NotifyManager::registerChannel('slack', new SlackChannel());
}
```

### Configuração Avançada de Regras

[](#configuração-avançada-de-regras)

```
$advancedRule = NotificationRuleDTO::create(
    name: 'Notificações Premium Usuário VIP',
    channel: 'telegram',
    conditions: [
        [
            'field' => 'recipient',
            'operator' => 'in',
            'value' => ['123456789', '987654321'] // IDs de chat de usuários VIP
        ],
        [
            'field' => 'priority',
            'operator' => '>=',
            'value' => 2
        ]
    ],
    options: [
        'max_sends_per_hour' => 10,
        'max_sends_per_day' => 50,
        'allowed_days' => [1, 2, 3, 4, 5], // Segunda a Sexta
        'allowed_hours' => range(9, 18), // 9h às 18h
        'start_date' => now(),
        'end_date' => now()->addMonths(6),
        'priority' => 1
    ]
);
```

Esquema do Banco de Dados
-------------------------

[](#esquema-do-banco-de-dados)

O pacote cria três tabelas principais:

### notification\_rules

[](#notification_rules)

Armazena regras de envio e condições para notificações.

### notification\_logs

[](#notification_logs)

Rastreia todas as atividades de notificação com status e respostas.

### notification\_usages

[](#notification_usages)

Registra dados de monetização para rastreamento de custos e faturamento.

Testes
------

[](#testes)

Execute a suíte de testes:

```
composer test
```

Execute testes com cobertura de código:

```
composer test-coverage
```

Gere relatório HTML de cobertura:

```
composer test-coverage-html
```

O relatório HTML será gerado no diretório `coverage/index.html`.

Formate código com Pint:

```
composer format
```

### Configuração do Xdebug

[](#configuração-do-xdebug)

Para que a cobertura de código funcione, certifique-se de que o Xdebug está instalado e configurado. Os scripts do Composer já configuram automaticamente o modo de cobertura (`XDEBUG_MODE=coverage`).

Se você quiser configurar manualmente, adicione ao seu `php.ini`:

```
xdebug.mode=coverage
```

Ou use a variável de ambiente:

```
$env:XDEBUG_MODE="coverage" # Windows PowerShell
export XDEBUG_MODE=coverage # Linux/Mac
```

Recursos de Monetização
-----------------------

[](#recursos-de-monetização)

Rastreie custos e uso de notificações:

```
// Obter custo de uma notificação
$cost = NotifyManager::calculateCost($notification);

// Custos são automaticamente registrados quando notificações são enviadas
// Consulte dados de uso no modelo NotificationUsage
$usage = \NotifyManager\Models\NotificationUsage::where('channel', 'email')
    ->whereDate('used_at', today())
    ->sum('cost');
```

Log e Monitoramento
-------------------

[](#log-e-monitoramento)

Todas as atividades de notificação são automaticamente registradas:

```
// Consultar logs de notificação
$logs = \NotifyManager\Models\NotificationLog::where('status', 'sent')
    ->where('channel', 'email')
    ->whereDate('sent_at', today())
    ->get();

// Verificar notificações falhadas
$failures = \NotifyManager\Models\NotificationLog::where('status', 'failed')
    ->with('usage')
    ->latest()
    ->get();
```

Limitação de Taxa
-----------------

[](#limitação-de-taxa)

Configure limites de taxa globalmente ou por regra:

```
// Limitação de taxa global na configuração
'rate_limiting' => [
    'default_max_per_hour' => 100,
    'default_max_per_day' => 1000,
    'enable_global_limits' => true,
],

// Limitação de taxa por regra
$rule = NotificationRuleDTO::create(
    // ... outros parâmetros
    options: [
        'max_sends_per_hour' => 10,
        'max_sends_per_day' => 50,
    ]
);
```

Integração com Filas
--------------------

[](#integração-com-filas)

Habilite processamento em filas para melhor performance:

```
// Em config/notify-manager.php
'queue' => [
    'enabled' => true,
    'connection' => 'redis',
    'queue_name' => 'notifications',
],
```

Referência da API
-----------------

[](#referência-da-api)

### NotificationManager

[](#notificationmanager)

#### Métodos Síncronos

[](#métodos-síncronos)

```
// Enviar notificação imediatamente
NotifyManager::send(NotificationDTO $notification): bool

// Calcular custo da notificação
NotifyManager::calculateCost(NotificationDTO $notification): float

// Registrar canal personalizado
NotifyManager::registerChannel(string $name, NotificationChannelInterface $channel): void

// Obter canal registrado
NotifyManager::getChannel(string $name): ?NotificationChannelInterface

// Criar regra de notificação
NotifyManager::createRule(NotificationRuleDTO $rule): bool

// Verificar se deve enviar baseado nas regras
NotifyManager::shouldSend(NotificationDTO $notification): bool

// Registrar atividade manualmente
NotifyManager::logActivity(NotificationDTO $notification, string $status, ?string $response = null): void
```

#### Métodos Assíncronos (Queue)

[](#métodos-assíncronos-queue)

```
// Enviar notificação via fila
NotifyManager::sendAsync(NotificationDTO $notification, ?int $delay = null): void

// Agendar notificação para momento específico
NotifyManager::sendAt(NotificationDTO $notification, \DateTimeInterface $when): void
```

### DTOs

[](#dtos)

#### NotificationDTO

[](#notificationdto)

```
NotificationDTO::create(
    channel: string,           // Canal de envio (obrigatório)
    recipient: string,         // Destinatário (obrigatório)
    message: string,          // Mensagem (obrigatório)
    options: [                // Opções (opcional)
        'subject' => string,      // Assunto
        'priority' => int,        // Prioridade (1-3)
        'tags' => array,          // Tags para categorização
        'template' => string,     // Nome do template
        'template_data' => array, // Dados para o template
        'metadata' => array,      // Metadados extras
        'rules' => array,         // Regras inline (sobrescreve regras do banco)
    ]
): NotificationDTO
```

##### Regras Inline

[](#regras-inline)

Você pode passar regras diretamente no `NotificationDTO` usando o parâmetro `rules`. Quando fornecido, essas regras terão prioridade sobre as regras armazenadas no banco de dados para aquele canal:

```
use NotifyManager\Models\NotificationRule;

// Criar uma regra customizada
$customRule = new NotificationRule([
    'name' => 'High Priority Only',
    'channel' => 'email',
    'conditions' => [
        [
            'field' => 'priority',
            'operator' => '>=',
            'value' => 3,
        ],
    ],
    'is_active' => true,
    'max_sends_per_day' => 0,
    'max_sends_per_hour' => 5,
    'allowed_days' => [],
    'allowed_hours' => [9, 10, 11, 12, 13, 14, 15, 16, 17], // Horário comercial
    'priority' => 1,
    'metadata' => [],
]);

// Usar a regra inline na notificação
$notification = NotificationDTO::create(
    channel: 'email',
    recipient: 'user@example.com',
    message: 'Mensagem crítica',
    options: [
        'priority' => 3,
        'rules' => [$customRule], // Esta regra será usada em vez das regras do banco
    ]
);

// Múltiplas regras inline
$notification = NotificationDTO::create(
    channel: 'email',
    recipient: 'employee@company.com',
    message: 'Mensagem interna',
    options: [
        'priority' => 2,
        'rules' => [$priorityRule, $recipientRule, $timeRule], // Todas devem passar
    ]
);
```

**Vantagens das Regras Inline:**

- ✅ Maior flexibilidade por notificação
- ✅ Não dependem do banco de dados
- ✅ Ideais para regras temporárias ou específicas
- ✅ Sobrescrevem regras globais quando necessário
- ✅ Permitem lógica de negócio mais dinâmica

### Mensagens Personalizadas com Metadados

[](#mensagens-personalizadas-com-metadados)

O NotifyManager suporta mensagens personalizadas através dos metadados das regras. Quando uma regra é aplicada, você pode substituir a mensagem original por uma versão customizada.

#### Configurando Mensagens Personalizadas

[](#configurando-mensagens-personalizadas)

```
use NotifyManager\DTOs\NotificationRuleDTO;

// Regra para notificações urgentes com mensagem personalizada
$urgentRule = NotificationRuleDTO::create(
    name: 'Urgent Notifications',
    channel: 'telegram',
    conditions: [
        ['field' => 'priority', 'operator' => '>=', 'value' => 3],
        ['field' => 'urgency_date', 'operator' => '=', 'value' => 'D+0'] // Hoje
    ],
    options: [
        'metadata' => [
            'custom_message' => '🚨 URGENTE: {original_message}\n\n⏰ Data: {date}\n👤 Para: {recipient}\n📧 ID: {notification_id}',
            'custom_subject' => '🚨 ALERTA URGENTE - {subject}',
            'additional_tags' => ['urgent', 'today'],
            'notification_type' => 'urgent_today'
        ]
    ]
);
```

#### Placeholders Disponíveis

[](#placeholders-disponíveis)

**Placeholders da Notificação:**

- `{recipient}` - Destinatário da notificação
- `{original_message}` - Mensagem original
- `{priority}` - Prioridade da notificação
- `{subject}` - Assunto da notificação
- `{notification_id}` - ID único da notificação
- `{tags}` - Tags da notificação (separadas por vírgula)

**Placeholders de Data/Hora:**

- `{date}` - Data atual (YYYY-MM-DD)
- `{time}` - Hora atual (HH:mm:ss)
- `{datetime}` - Data e hora completa

**Placeholders dos Metadados:**

- `{field_name}` - Qualquer campo dos metadados da notificação
- `{rule_field_name}` - Qualquer campo dos metadados da regra (prefixo `rule_`)

#### Exemplo com Regras D+N e D-N

[](#exemplo-com-regras-dn-e-d-n)

```
// Regra para lembretes futuros (D+3)
$reminderRule = NotificationRuleDTO::create(
    name: 'Future Reminder D+3',
    channel: 'email',
    conditions: [
        ['field' => 'type', 'operator' => '=', 'value' => 'reminder'],
        ['field' => 'reminder_date', 'operator' => '=', 'value' => 'D+3']
    ],
    options: [
        'metadata' => [
            'custom_message' => '📅 EM 3 DIAS ({date}): {original_message}\n\n💡 Prepare-se: {preparation_notes}',
            'custom_subject' => '📅 Lembrete - {subject}',
            'reminder_type' => 'future_planning'
        ]
    ]
);

// Regra para follow-ups passados (D-7)
$followUpRule = NotificationRuleDTO::create(
    name: 'Follow-up D-7',
    channel: 'slack',
    conditions: [
        ['field' => 'type', 'operator' => '=', 'value' => 'follow_up'],
        ['field' => 'reference_date', 'operator' => '=', 'value' => 'D-7']
    ],
    options: [
        'metadata' => [
            'custom_message' => '🔄 HÁ 7 DIAS ({date}): {original_message}\n\n📊 Status: {current_status}\n⏱️ Tempo decorrido: 7 dias',
            'custom_subject' => '🔄 Follow-up - {subject}',
            'follow_up_type' => 'weekly_review'
        ]
    ]
);
```

#### Uso com Notificações

[](#uso-com-notificações)

```
// Notificação que será personalizada pela regra
$notification = NotificationDTO::create(
    channel: 'telegram',
    recipient: '@john_doe',
    message: 'Sistema crítico fora do ar',
    options: [
        'priority' => 3,
        'subject' => 'Falha Crítica',
        'metadata' => [
            'urgency_date' => 'D+0',
            'system' => 'payment_gateway',
            'severity' => 'critical'
        ]
    ]
);

// A mensagem será automaticamente personalizada
NotifyManager::send($notification);

// Resultado:
// 🚨 URGENTE: Sistema crítico fora do ar
//
// ⏰ Data: 2024-03-15
// 👤 Para: @john_doe
// 📧 ID: notification_abc123
```

#### Campos Especiais nos Metadados

[](#campos-especiais-nos-metadados)

```
'metadata' => [
    'custom_message' => 'Sua mensagem com {placeholders}',     // Obrigatório
    'custom_subject' => 'Assunto customizado - {subject}',     // Opcional
    'additional_tags' => ['urgent', 'custom'],                 // Opcional
    'template_data' => ['key' => 'value'],                     // Opcional
    // ... outros campos personalizados
]
```

Para exemplos mais detalhados, consulte:

- `examples/custom-messages-example.php`
- `examples/date-based-rules-example.php`
- `docs/CUSTOM_MESSAGES.md`

#### NotificationRuleDTO

[](#notificationruledto)

```
NotificationRuleDTO::create(
    name: string,              // Nome da regra (obrigatório)
    channel: string,           // Canal (obrigatório)
    conditions: array,         // Condições (opcional)
    options: [                 // Opções (opcional)
        'allowed_days' => array,      // Dias permitidos (0-6)
        'allowed_hours' => array,     // Horas permitidas (0-23)
        'max_sends_per_day' => int,   // Limite diário
        'max_sends_per_hour' => int,  // Limite por hora
        'start_date' => Carbon,       // Data início
        'end_date' => Carbon,         // Data fim
        'priority' => int,            // Prioridade
        'metadata' => array,          // Metadados
        'is_active' => bool,          // Status ativo
    ]
): NotificationRuleDTO
```

### Modelos Eloquent

[](#modelos-eloquent)

#### NotificationLog

[](#notificationlog)

```
// Buscar logs por status
NotificationLog::where('status', 'sent')->get()

// Buscar logs por canal
NotificationLog::where('channel', 'email')->get()

// Buscar logs com falhas
NotificationLog::where('status', 'failed')
    ->with('usage')
    ->latest()
    ->get()
```

#### NotificationUsage

[](#notificationusage)

```
// Calcular custos por canal
NotificationUsage::where('channel', 'email')->sum('cost')

// Buscar uso por período
NotificationUsage::whereBetween('used_at', [$start, $end])->get()
```

#### NotificationRule

[](#notificationrule)

```
// Buscar regras ativas
NotificationRule::where('is_active', true)->get()

// Buscar regras por canal
NotificationRule::where('channel', 'email')
    ->where('is_active', true)
    ->get()
```

📁 Exemplos
----------

[](#-exemplos)

O diretório `examples/` contém implementações práticas:

- **Templates Blade**: Exemplos de templates para diferentes tipos de notificação
- **Controller**: Controller completo com endpoints para notificações
- **Configurações**: Exemplos de configuração de filas e workers
- **Métricas**: Queries para dashboard e monitoramento

Veja o [README dos exemplos](examples/README.md) para instruções detalhadas.

Roadmap
-------

[](#roadmap)

### Versão 1.1

[](#versão-11)

- Canais adicionais (SMS, Push Notifications)
- Dashboard web para gerenciamento
- Métricas e analytics avançados
- Templates visuais com editor

### Versão 1.2

[](#versão-12)

- Integração com provedores externos
- Sistema de webhooks
- API REST completa
- Multi-tenancy

Contribuindo
------------

[](#contribuindo)

Damos as boas-vindas a contribuições! Por favor, veja [CONTRIBUTING.md](CONTRIBUTING.md) para detalhes.

Segurança
---------

[](#segurança)

Se você descobrir qualquer problema relacionado à segurança, por favor envie um email para  ao invés de usar o rastreador de issues.

Licença
-------

[](#licença)

A Licença MIT (MIT). Por favor veja [Arquivo de Licença](LICENSE.md) para mais informações.

Changelog
---------

[](#changelog)

Por favor veja [CHANGELOG.md](CHANGELOG.md) para mais informações sobre o que mudou recentemente.

Suporte
-------

[](#suporte)

Para suporte, por favor crie uma issue no GitHub ou entre em contato conosco em

###  Health Score

35

—

LowBetter than 77% of packages

Maintenance60

Regular maintenance activity

Popularity7

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity56

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~8 days

Total

6

Last Release

270d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/1509447?v=4)[Luis Paulo](/maintainers/Ferreiramg)[@Ferreiramg](https://github.com/Ferreiramg)

---

Top Contributors

[![Ferreiramg](https://avatars.githubusercontent.com/u/1509447?v=4)](https://github.com/Ferreiramg "Ferreiramg (9 commits)")

---

Tags

pluginlaravelemailnotificationslackmessagingtelegramwhatsappmonetization

###  Code Quality

TestsPest

Code StyleLaravel Pint

### Embed Badge

![Health badge](/badges/ferreiramg-notify-manager/health.svg)

```
[![Health](https://phpackages.com/badges/ferreiramg-notify-manager/health.svg)](https://phpackages.com/packages/ferreiramg-notify-manager)
```

###  Alternatives

[psalm/plugin-laravel

Psalm plugin for Laravel

3355.3M346](/packages/psalm-plugin-laravel)[laravel/pulse

Laravel Pulse is a real-time application performance monitoring tool and dashboard for your Laravel application.

1.7k15.1M132](/packages/laravel-pulse)[roots/acorn

Framework for Roots WordPress projects built with Laravel components.

9762.4M131](/packages/roots-acorn)[propaganistas/laravel-disposable-email

Disposable email validator

6023.0M7](/packages/propaganistas-laravel-disposable-email)[mike-bronner/laravel-model-caching

Automatic caching for Eloquent models.

2.4k91.9k1](/packages/mike-bronner-laravel-model-caching)[laravel/ai

The official AI SDK for Laravel.

1.0k3.2M200](/packages/laravel-ai)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)