sfp_api_laravel_diarista/app/Services/Pagarme/PagarmePaymentService.php

<?php

namespace App\Services\Pagarme;

use App\Data\Pagarme\Request\PagarmeCustomerRequestData\PagarmeCustomerRequestData;
use App\Data\Pagarme\Request\PagarmeOrderRequestData\PagarmeOrderItemData;
use App\Data\Pagarme\Request\PagarmeOrderRequestData\PagarmeOrderPaymentData\PagarmeOrderCreditCardData;
use App\Data\Pagarme\Request\PagarmeOrderRequestData\PagarmeOrderPaymentData\PagarmeOrderPaymentData;
use App\Data\Pagarme\Request\PagarmeOrderRequestData\PagarmeOrderPaymentData\PagarmeOrderPixData;
use App\Data\Pagarme\Request\PagarmeOrderRequestData\PagarmeOrderRequestData;
use App\Data\Pagarme\Response\PagarmeOrderResponseData\PagarmeOrderResponseData;
use App\Enums\PaymentSplitStatusEnum;
use App\Enums\PaymentStatusEnum;
use App\Models\Payment;
use App\Models\PaymentSplit;
use App\Services\Pagarme\Concerns\SendsPagarmeRequests;
use Illuminate\Support\Str;

class PagarmePaymentService
{
    use SendsPagarmeRequests;

    public function createOrderWithCreditCard(
        Payment $payment,
        array $items,
        PagarmeCustomerRequestData $customer,
        PagarmeOrderCreditCardData $creditCard,
        array $options = []
    ): array {
        return $this->createOrder(
            payment: $payment,
            items: $items,
            customer: $customer,
            paymentMethod: PagarmeOrderRequestData::creditCardPaymentMethod(
                creditCard: $creditCard,
                split: is_array($options['split'] ?? null) ? $options['split'] : null,
            ),
            options: $options,
        );
    }

    public function createOrderWithPix(
        Payment $payment,
        array $items,
        PagarmeCustomerRequestData $customer,
        PagarmeOrderPixData $pix,
        array $options = []
    ): array {
        return $this->createOrder(
            payment: $payment,
            items: $items,
            customer: $customer,
            paymentMethod: PagarmeOrderRequestData::pixPaymentMethod(
                pix: $pix,
                split: is_array($options['split'] ?? null) ? $options['split'] : null,
            ),
            options: $options,
        );
    }

    // criacao de pedidos por metodo de pagamento

    public function createOrder(
        Payment $payment,
        array $items,
        PagarmeCustomerRequestData $customer,
        PagarmeOrderPaymentData $paymentMethod,
        array $options = []
    ): array {
        $requestData = PagarmeOrderRequestData::fromOrderPayload(
            code: $this->ensurePaymentCode($payment),
            items: $items,
            customer: $customer,
            paymentMethod: $paymentMethod,
            metadata: array_merge([
                'payment_id'  => (string) $payment->id,
                'schedule_id' => (string) $payment->schedule_id,
                'client_id'   => (string) $payment->client_id,
                'provider_id' => (string) $payment->provider_id,
            ], $options['metadata'] ?? []),
            customerId: $options['customer_id'] ?? null,
            closed: $options['closed'] ?? true,
            channel: $options['channel'] ?? null,
        );

        $order = PagarmeOrderResponseData::fromArray($this->pagarmeRequest(
            method: 'POST',
            path: '/orders',
            payload: $requestData,
            idempotencyKey: $this->idempotencyKey($payment),
            errorMessage: 'Erro ao criar pedido de pagamento no Pagar.me.',
        ));

        $order->requireId();

        return $order->toArray();
    }

    // evita criacao duplicada de pedidos

    private function idempotencyKey(Payment $payment): string
    {
        return "payment-{$payment->id}-schedule-{$payment->schedule_id}";
    }

    private function ensurePaymentCode(Payment $payment): string
    {
        if (! empty($payment->gateway_code)) {
            return $payment->gateway_code;
        }

        $code = 'payment-'.(string) Str::uuid();

        $payment->forceFill(['gateway_code' => $code])->save();

        return $code;
    }

    //

    public function applyGatewayResponseToPayment(Payment $payment, array $orderResponse): Payment
    {
        $order = PagarmeOrderResponseData::fromArray($orderResponse);
        $newStatus = $order->paymentStatus();
        $failureCode = null;
        $failureMessage = null;

        if ($newStatus === PaymentStatusEnum::FAILED) {
            $failureCode = $order->failureCode();
            $failureMessage = $order->failureMessage();
        }

        $payment->forceFill([
            'gateway_provider'            => 'pagarme',
            'gateway_entity_reference'    => $order->gatewayEntityReference(),
            'gateway_entity_label'        => $order->gatewayEntityLabel(),
            'gateway_operation_reference' => $order->gatewayOperationReference(),
            'gateway_operation_label'     => $order->gatewayOperationLabel(),
            'status'                      => $newStatus,
            'paid_at'                     => $order->paidAt(),
            'authorized_at'               => $order->authorizedAt(),
            'gateway_payload'             => $orderResponse,
            'failure_code'                => $failureCode,
            'failure_message'             => $failureMessage,
        ])->save();

        $splitStatus = match ($newStatus) {
            PaymentStatusEnum::PAID       => PaymentSplitStatusEnum::TRANSFERRED,
            PaymentStatusEnum::FAILED     => PaymentSplitStatusEnum::FAILED,
            PaymentStatusEnum::CANCELLED  => PaymentSplitStatusEnum::CANCELLED,
            PaymentStatusEnum::AUTHORIZED => PaymentSplitStatusEnum::PROCESSING,
            default                       => PaymentSplitStatusEnum::PENDING,
        };

        PaymentSplit::query()
            ->where('payment_id', $payment->id)
            ->update(['status' => $splitStatus]);

        return $payment->fresh();
    }
}