Notification::sendTelegramRequest() - Code Metrics - Inspection of "refactor: optimize" - cslant/telegram-git-notifier - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( 1a1ee7...5cb4cc )

by Tan
created 2025-07-12 07:57 UTC
Notification::sendTelegramRequest() A

↳ Parent: Notification
Complexity

Conditions	2
Paths	2
Size

Total Lines	14
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	10
dl	0
loc	14
rs	9.9332
c	0
b	0
f	0
cc	2
nc	2
nop	1
<?php

declare(strict_types=1);

namespace CSlant\TelegramGitNotifier\Structures;

use CSlant\TelegramGitNotifier\Constants\EventConstant;
use CSlant\TelegramGitNotifier\Exceptions\MessageIsEmptyException;
use CSlant\TelegramGitNotifier\Exceptions\SendNotificationException;
use GuzzleHttp\Exception\GuzzleException;
use JsonException;
use RuntimeException;
use Symfony\Component\HttpFoundation\Request;

/**
 * Trait Notification
 * 
 * Handles notification-related functionality including message formatting
 * and sending notifications to Telegram.
 */
trait Notification
{
    /** @var object The payload received from the webhook */
    public object $payload;

    /** @var string The formatted message to be sent */
    public string $message = '';

    /**
     * Send an access denied message to the chat
     *
     * @param string|null $chatId The chat ID to send the message to
     * @param string|null $viewTemplate Custom view template to use
     * @throws SendNotificationException If the message cannot be sent
     */
    public function accessDenied(
        ?string $chatId = null,
        ?string $viewTemplate = null
    ): void {
        try {
            $template = $viewTemplate ?? config('telegram-git-notifier.view.globals.access_denied');
            $message = tgn_view($template, ['chatId' => $chatId]);

            if (empty($message)) {
                throw new MessageIsEmptyException('Access denied message template is empty');
            }

            $this->telegram->sendMessage([
                'chat_id' => $this->chatBotId,
                'text' => $message,
                'disable_web_page_preview' => true,
                'parse_mode' => 'HTML',
            ]);
        } catch (\Exception $e) {
            throw SendNotificationException::create('Failed to send access denied message', 0, $e);
            throw SendNotificationException::/** @scrutinizer ignore-call */ create('Failed to send access denied message', 0, $e);
        }
    }

    /**
     * Set the payload from the incoming request
     *
     * @param Request $request The HTTP request
     * @param string $event The event type
     * @return object The parsed payload
     * @throws MessageIsEmptyException If the payload is empty or invalid
     */
    public function setPayload(Request $request, string $event): object
    {
        $content = $this->extractContentFromRequest($request);
        
        if ($content === null) {
            throw new MessageIsEmptyException('No content found in the request');
        }

        try {
            $this->payload = json_decode($content, false, 512, JSON_THROW_ON_ERROR);
            $this->setMessage($event);
            
            return $this->payload;
        } catch (JsonException $e) {
            throw new MessageIsEmptyException('Invalid JSON payload: ' . $e->getMessage(), 0, $e);
        }
    }

    /**
     * Extract content from the request based on the platform
     */
    private function extractContentFromRequest(Request $request): ?string
    {
        if ($this->event->platform === 'gitlab') {
            return $request->getContent() ?: null;
        }
        
        if ($this->event->platform === EventConstant::DEFAULT_PLATFORM) {
            return $request->request->get('payload');
        }
        
        return null;
    }

    /**
     * Set the message from the payload using the appropriate template
     *
     * @param string $eventType The type of event
     * @throws MessageIsEmptyException If the message cannot be generated
     */
    private function setMessage(string $eventType): void
    {
        $event = tgn_event_name($eventType);
        $action = $this->getActionOfEvent($this->payload);
        $action = $this->getActionOfEvent($this->payload);
        
        $viewTemplate = $this->buildViewTemplate($event, $action);
        $viewData = [
            'payload' => $this->payload,
            'event' => tgn_convert_event_name($eventType),
        ];

        $viewResult = tgn_view($viewTemplate, $viewData);

        if ($viewResult === null) {
            throw MessageIsEmptyException::create(
                "Failed to generate message for event: {$eventType}"
            throw MessageIsEmptyException::/** @scrutinizer ignore-call */ create(
            );
        }

        $this->message = $viewResult;
    }

    /**
     * Build the view template path based on event and action
     */
    private function buildViewTemplate(string $event, ?string $action): string
    {
        $template = "events.{$this->event->platform}.{$event}";
        
        return $action 
            ? "{$template}.{$action}" 
            : "{$template}.default";
    }

    /**
     * Send a notification to Telegram
     *
     * @param string|null $message The message to send (uses stored message if null)
     * @param array<string, mixed> $options Additional options for the Telegram API
     * @return bool True if the notification was sent successfully
     * @throws SendNotificationException If the notification fails to send
     */
    public function sendNotify(?string $message = null, array $options = []): bool
    {
        $this->message = $message ?? $this->message;

        if (trim($this->message) === (config('telegram-git-notifier.view.ignore-message') ?? '')) {
            return false;
        }

        try {
            $queryParams = array_merge(
                $this->createTelegramBaseContent(),
                       createTelegramBaseContent(),
                ['text' => $this->message],
                $options
            );

            $response = $this->sendTelegramRequest($queryParams);
            return $response->getStatusCode() === 200;
        } catch (\Exception $e) {
            throw new SendNotificationException(
                'Failed to send notification: ' . $e->getMessage(),
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * Send a request to the Telegram API
     *
     * @param array<string, mixed> $queryParams The query parameters to send
     * @return \Psr\Http\Message\ResponseInterface The API response
     * @throws \RuntimeException If the request fails
     */
    private function sendTelegramRequest(array $queryParams): \Psr\Http\Message\ResponseInterface
    {
        $url = 'https://api.telegram.org/bot' . config('telegram-git-notifier.bot.token') . '/sendMessage';
        
        try {
            return $this->client->request('POST', $url, [
                'form_params' => $queryParams,
                'verify' => config('telegram-git-notifier.app.request_verify', true),
                'verify' => /** @scrutinizer ignore-call */ config('telegram-git-notifier.app.request_verify', true),
            ]);
        } catch (\Exception $e) {
            throw new \RuntimeException(
                'Failed to send request to Telegram API: ' . $e->getMessage(),
                $e->getCode(),
                $e
            );
        }
    }
}

cslant / telegram-git-notifier

Push — main ( 1a1ee7...5cb4cc )

Notification::sendTelegramRequest() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
