How to know the type of notification received?

[daniel89fg]

Hello.

The WebHook class receives, reads, and returns a class based on the type of notification received. But how do we know the type it is?

In my controller I need to do a switch() based on the notification type. But I don't see a way to know if it is: text, sticker, image, reaction, audio, etc...

I only have to get the name of the class and see what its final extension is.

Is there a function that returns the type of the message?

Thank you.

[usyeimar]

As far as I know there isn't, but you can use instanceof to determine the type, as follows
Those are the types returned by the NotificationFactoy

    public function __invoke(array $data): void
    {
        $event = $this->webhook->read($data);

        Storage::disk('public')->put('events.log', print_r($event, true));
        //Contact Type Notification
        if ($event instanceof Contact) {
            Log::info('Contacto: ', [$event]);
        }

        //Text Type Notification
        if ($event instanceof Text) {
            $exists = self::processEvents($event->id());

            if ($exists->isEmpty()) {
                self::saveMessage(
                    wamId: $event->id(),
                    name: $event->customer()->name(),
                    waId: $event->customer()->phoneNumber(),
                    type: 'text',
                    timestamp: $event->receivedAt(),
                    body: $event->message(),
                    caption: null,
                    data: null,
                )->save();
            }
        }

        //Media Type Notification
        if ($event instanceof Media) {
            $exists = self::processEvents($event->id());
            if ($exists->isEmpty()) {
                self::saveMessage(
                    wamId: $event->id(),
                    name: $event->customer()->name(),
                    waId: $event->customer()->phoneNumber(),
                    type: 'image',
                    timestamp: $event->receivedAt(),
                    body: self::compileMedia($event->imageId(), $event->mimeType()),
                    caption: $event->caption(),
                    data: null,
                )->save();
            }
        }

        //Location Type Notification
        if ($event instanceof Location) {
            Log::info('Location: ', [$event]);
        }

        //Reaction Type Notification
        if ($event instanceof Reaction) {
            Log::info('Reaction: ', [$event]);
        }

        //Button Type Notification
        if ($event instanceof Button) {
            Log::info('Button: ', [$event]);
        }

        //System Type Notification

        if ($event instanceof System) {
            Log::info('System: ', [$event]);
        }

        //Order Type Notification
        if ($event instanceof Order) {
            Log::info('Order: ', [$event]);
        }

        //Interactive Type Notification
        if ($event instanceof Interactive) {
            Log::info('Interactive: ', [$event]);
        }
        //Unknown Type Notification 
        if ($event instanceof Unknown) {
            Log::info('Unknown: ', [$event]);
        }

        //StatusNotification Type Notification
        if ($event instanceof StatusNotification) {
            $status = $event->status(); // sent, delivered, read
            $wam = Messages::query()->where('wam_id', $event->id())->first();
            if (! empty($wam)) {
                $wam->status = $status;
                $wam->save();

                self::emitWhatsAppWebhookEvent($wam, true);
            }
        }
    }

[daniel89fg]

Thank you so much. exactly that was doing. However, I would add as a suggestion a function to obtain the type, since in the upper class the type is used for switch and to know which class to use.

[usyeimar]

Hmm... You're right, by reading the discussion in a more detailed way you can understand your real problem, based on that, in my development implementation I made the following function

I encapsulated the logic to extract the type in a trait and then called it in my parent class which processes all the events.

namespace App\Services\Api\Whatsapp\Webhook\Utils;

trait ExtractMessagesTypes
{
    public function type(): ?string
    {
        if (! is_array($this->payload['entry'] ?? null)) {
            return null;
        }

        $entry = $this->payload['entry'][0] ?? [];
        $message = $entry['changes'][0]['value']['messages'][0] ?? [];
        if ($message) {
            return $message['type'];
        }

        return null;
    }
}

<?php

declare(strict_types=1);

namespace App\Services\Api\Whatsapp\Webhook;

use App\Events\WhatsappWebhookNotificationsEvents;
use App\Models\Contacts\Contact;
use App\Models\Messages\Messages;
use App\Services\Api\Whatsapp\Webhook\Types\HasContactEvent;
use App\Services\Api\Whatsapp\Webhook\Types\HasInteractiveEvent;
use App\Services\Api\Whatsapp\Webhook\Types\HasLocationEvent;
use App\Services\Api\Whatsapp\Webhook\Types\HasMediaEvent;
use App\Services\Api\Whatsapp\Webhook\Types\HasOrderEvent;
use App\Services\Api\Whatsapp\Webhook\Types\HasReactionEvent;
use App\Services\Api\Whatsapp\Webhook\Types\HasStatusNotificationEvent;
use App\Services\Api\Whatsapp\Webhook\Types\HasSystemEvent;
use App\Services\Api\Whatsapp\Webhook\Types\HasTextEvent;
use App\Services\Api\Whatsapp\Webhook\Types\HasUnknownEvent;
use App\Services\Api\Whatsapp\Webhook\Utils\ExtractMessagesTypes;
use DateTimeInterface;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Netflie\WhatsAppCloudApi\Response\ResponseException;
use Netflie\WhatsAppCloudApi\WebHook;
use Netflie\WhatsAppCloudApi\WebHook\Notification;

final class WebhookReadServices
{
    use ExtractMessagesTypes,
        HasTextEvent,
        HasMediaEvent,
        HasContactEvent,
        HasInteractiveEvent,
        HasLocationEvent,
        HasOrderEvent,
        HasReactionEvent,
        HasStatusNotificationEvent,
        HasSystemEvent,
        HasUnknownEvent;

    protected Notification $event;

    private ?array $contact = null;

    private array $payload;

    public function __construct(private readonly WebHook $webhook)
    {
    }

    /**
     * Procesamos todos los tipos de mensajes permitidos por facebook.
     *
     * @param array $data
     * @return void
     * @throws ResponseException
     */
    public function __invoke(array $data): void
    {
        $this->event = $this->webhook->read($data);
        $this->payload = $data;
        Storage::disk('public')->put('events.log', print_r($this->event, true));

        //Verificamos si el mensaje ya existe en la base de datos.
        $exists = self::existsMessageInDatabase($this->event->id());

        if ($exists->isEmpty()) {
            //Procedemos a consultar si el contacto existe en la base de datos.
            $contact = Contact::query()
                ->where('phoneId', $this->event->customer()->phoneNumber())
                ->get();

            //Si el contacto no existe lo creamos.
            if ($contact->count() > 0) {
                $this->contact = $contact->all();
            } else {
                $this->contact = Contact::query()
                    ->create([

                        'first_name' => $this->event->customer()->name(),
                        'last_name' => null,
                        'email' => null,
                        'phone' => $this->event->customer()->phoneNumber(),
                        'phoneId' => (int) $this->event->customer()->phoneNumber(),
                        'country' => null,
                        'address' => null,
                        'city' => null,
                        'state' => null,
                        'user_id' => null,
                        'tag_id' => null,
                    ])->get()->all();
            }

            //Procedemos a guardar el mensaje en la base de datos con el id del contacto.
            $this->text();
            $this->media();
            $this->contact();
            $this->interactive();
            $this->location();
            $this->order();
            $this->reaction();
            $this->statusNotification();
            $this->system();
            $this->unknown();
        }
    }

    /**
     * Verificamos si el evento ya existe en la base de datos.
     *
     * @param string $wamId
     * @return Collection
     */
    private static function existsMessageInDatabase(
        string $wamId
    ): Collection {
        return Messages::query()
            ->where('wam_id', $wamId)
            ->orderBy('created_at', 'desc')
            ->limit(1)
            ->get();
    }

    /**
     * Guardamos el mensaje en la base de datos - Messages.
     *
     * @param string $wamId
     * @param string|null $name
     * @param string $waId
     * @param string $type
     * @param DateTimeInterface|null $timestamp
     * @param string $body
     * @param string|null $caption
     * @param string|null $data
     * @param int|null $contactId
     * @return Messages
     */
    private function saveMessage(
        string $wamId,
        ?string $name,
        string $waId,
        string $type,
        ?DateTimeInterface $timestamp,
        string $body,
        ?string $caption,
        ?string $data,
        ?int $contactId
    ): Messages {
        $chat_model = Messages::query()->create(attributes: [
            'wa_id' => $waId,
            'name' => $name,
            'wam_id' => $wamId,
            'type' => $type,
            'body' => $body,
            'status' => 'sent',
            'caption' => $caption,
            'data' => $data,
            'contact_id' => $contactId,
            'created_at' => $timestamp->format('Y-m-d H:i:s'),
            'updated_at' => $timestamp->format('Y-m-d H:i:s'),
        ]);

        self::emitWhatsAppWebhookEvent($chat_model);

        return $chat_model;
    }

    /**
     * Guardamos el binario del archivo en el storage.
     *
     * @param string $mediaId
     * @param string $mimeType
     * @return string
     *
     * @throws ResponseException
     */
    private static function compileMedia(string $mediaId, string $mimeType): string
    {
        //Descargamos el archivo
        $download_resource = whatsapp()->downloadMedia($mediaId);
        //Obtenemos el tipo de archivo
        $mimeType = explode(';', $mimeType)[0];

        //Generamos un nombre unico para el archivo
        $fileName = Str::uuid()->toString().'.'.mime($mimeType);
        //Guardamos el archivo en el disco publico
        Storage::disk('public')->put($fileName, $download_resource->body());

        //Retornamos el nombre del archivo

        return $fileName;
    }

    /**
     * Emitimos el evento de WhatsappWebhookNotificationsEvents.
     *
     * @param Messages|null $chat_model
     * @param bool $change
     * @return void
     */
    private static function emitWhatsAppWebhookEvent(
        ?Messages $chat_model,
        bool $change = false
    ): void {
        event(
            new WhatsappWebhookNotificationsEvents(
                message: $chat_model,
                change: $change,
            )
        );
    }
}

And in the event trait we call the function that does not return the type

<?php

namespace App\Services\Api\Whatsapp\Webhook\Types;

use Netflie\WhatsAppCloudApi\Response\ResponseException;
use Netflie\WhatsAppCloudApi\WebHook\Notification\Media;

trait HasMediaEvent
{
    /**
     * @throws ResponseException
     */
    public function media(): void
    {
        if ($this->event instanceof Media) {
            self::saveMessage(
                wamId: $this->event->id(),
                name: $this->event->customer()->name(),
                waId: $this->event->customer()->phoneNumber(),
                type: $this->type(), // <-- This the function call
                timestamp: $this->event->receivedAt(),
                body: self::compileMedia($this->event->imageId(), $this->event->mimeType(), $this->event->caption()),
                caption: $this->event->caption(),
                data: null,
                contactId: $this->contact['id'] ?? null,
            )->save();
        }
    }
}

[aalbarca]

You could open a PR with the code to add the new feature 🙏 @daniel89fg

[oscarlz]

I implemented a simple approach to get this into the current library but do not know if it's the best:

Added a variable and getters & setters to the MessageNotification class:

    private string $content_type;

    protected function getContentType(): string
    {
        return $this->content_type;
    }

    protected function setContentType(string $content_type): void
    {
        $this->content_type = $content_type;
    }

Which is the one that all the other Notifications for messages (not status messages) inherit from. I decided to call it $content_type instead of $notification_type because notifications received from WhatsApp can be "messages" or "statuses".

Then, on each of the messages types like the Text class, we add the type of the message and we pass it up to the parent $content_type variable:

    private string $content_type = 'text';

    public function __construct(string $id, Support\Business $business, string $message, string $received_at_timestamp)
    {
        parent::__construct($id, $business, $received_at_timestamp);

        $this->message = $message;
        
        $this->setContentType($this->content_type);
    }

Same pattern with all the other messages types, like the Interactive:

    private string $content_type = 'interactive';

    public function __construct(
        string $id,
        Support\Business $business,
        string $item_id,
        string $title,
        string $description,
        string $received_at_timestamp
    ) {
        parent::__construct($id, $business, $received_at_timestamp);

        $this->item_id = $item_id;
        $this->title = $title;
        $this->description = $description;

        $this->setContentType($this->content_type);
    }

Then, after we do read($payload) and we are sure we got a MessageNotification (not a StatusNotification) we can just do $notification->getContentType() to get the type string back.

What do you guys think? @aalbarca should I open a PR?.

[oscarlz]

Got anything to say about this @aalbarca? let's improve the library, it needs this.