eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

: /mnt/lmsestudio-instance-vol002/lms_491f64ca609b/app/Console/Commands/ [ drwxr-xr-x ]
name : PostProcessPostbacks.php
 <?php

namespace EstudioLMS\Console\Commands;

use Carbon\Carbon;
use EstudioLMS\Events\RecurringNotification;
use EstudioLMS\Models\Financial\Postback;
use EstudioLMS\Models\Financial\Recurring;
use EstudioLMS\Models\Subscription\Periodicity;
use EstudioLMS\Models\Financial\HireSubscription;
use Illuminate\Console\Command;
use EstudioLMS\Services\PagarMeService;
use EstudioLMS\Cart\Cart;
use EstudioLMS\Models\Subscription\Subscription;
use EstudioLMS\Models\Auth\User;

/**
 *
 */
class PostProcessPostbacks extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'recurrence:post-process';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Faz o cruzamento entre os registros de recorrência e os registros de postback. Ajusta a recorrência conforme a resposta do postback';
    /**
     * @var PagarMeService
     */
    private $pagarMeService;

    /**
     * Create a new command instance.
     *
     * @return void
     */
    public function __construct(
        PagarMeService $pagarMeService
    )
    {
        parent::__construct();
        $this->pagarMeService = $pagarMeService;
    }

    /**
     * Execute the console command.
     *
     * @return void
     */
    public function handle()
    {
        /*
         * Primeiro processa os boletos que foram emitidos, e estão no status 3
         */
        $today = Carbon::now()->toDateString();
        $recurrings = Recurring::where('payment_type', '=', 'boleto')
            ->where('status', '=', 3)
            ->where('next_attempt_date', '<=', $today)
            ->get();

        foreach ($recurrings as $recurring) {
            $user = User::find($recurring->user_id);
            if ($user) {
                $postback = Postback::where('subscription_id', '=', $recurring->payment_code)
                    ->latest()->first();
                $payload = json_decode($postback->payload, true);

                $subscriptionHash = $payload['transaction']['metadata']['subscription_hash'];
                $hiredSubscription = HireSubscription::where('subscription_hash', '=', $subscriptionHash)->first();
                $periodicityId = $hiredSubscription->periodicity_id;
                $periodicity = Periodicity::find($periodicityId);

                $subscription = Subscription::find($hiredSubscription->subscription_id);

                if ($payload['current_status'] == 'paid') {
                    $hireSubscriptionData = [
                        'payment_code' => $payload['id'],
                        'payment_type' => $payload['transaction']['payment_method'],
                        'card_id' => null,
                        'gross_amount' => $payload['transaction']['amount'] / 100,
                        'discount_amount' => 0,
                        'fee_amount' => 0.00,
                        'extra_amount' => 0,
                        'net_amount' => 0.00,
                        'status' => 1
                    ];
                    $hiredSubscription->fill($hireSubscriptionData);
                    $hiredSubscription->save();

                    $recurring->status = 1;
                    $recurring->attempts = $recurring->attempts + 1;
                    $recurring->payment_date = Carbon::parse($payload['transaction']['date_updated']);
                    $recurring->payment_code = $payload['id'];
                    $recurring->fee_amount = 0;
                    $recurring->net_amount = 0;
                    $recurring->save();

                    $dueDate = $this->dueDate($recurring->due_date, $periodicity->periodicity);
                    $nextAttemptDate = $this->nextAttemptDate($dueDate);

                    $cart = new Cart();
                    $cart->addItem(
                        $subscription->subscription_id,
                        $subscription->title,
                        $subscription->subscription_id,
                        $periodicity,
                        $recurring->gross_amount,
                        null,
                        0.00,
                        0.00,
                        0,
                        0.00,
                        true
                    );

                    $transaction = $this->pagarMeService->boletoTransaction(
                        $cart,
                        $subscriptionHash,
                        $recurring->user_id
                    );

                    $newRecurrenceData = [
                        'user_id' => $recurring->user_id,
                        'subscription_hash' => $payload['transaction']['metadata']['subscription_hash'],
                        'gateway_id' => 1,
                        'due_date' => $dueDate,
                        'next_attempt_date' => $this->nextAttemptDate($dueDate),
                        'payment_type' => $payload['transaction']['payment_method'],
                        'card_id' => null,
                        'payment_date' => null,
                        'attempts' => 0,
                        'gross_amount' => ($payload['transaction']['amount'] / 100),
                        'discount_amount' => null,
                        'fee_amount' => 0.00,
                        'extra_amount' => null,
                        'net_amount' => 0.00,
                        'charge_number' => $recurring->charge_number + 1,
                        'payment_code' => $transaction->getId(),
                        'status' => 3
                    ];
                    $newRecurrence = Recurring::create($newRecurrenceData);
                    \Event::fire(new RecurringNotification('boleto-issued', $transaction));
                    $this->info('Pagou a assinatura: ' . $recurring->subscription_hash);
                } elseif ($payload['current_status'] == 'waiting_payment') {
                    $today = Carbon::now()->toDateString();
                    $recurring->status = 3;
                    $recurring->attempts = $this->calculateAttempts($recurring->due_date, $today);
                    $recurring->next_attempt_date = Carbon::tomorrow()->toDateString();
                    $recurring->save();
                    $this->info('Assinatura não paga: ' . $recurring->subscription_hash);
                } else {
                    $this->info('Verificar o registro de recorrência com o id = ' . $recurring->id);
                    \Log::info('Verificar o registro de recorrência com o id = ' . $recurring->id);
                }
            } else {
                $hiredSubscription = HireSubscription::where('subscription_hash', '=', $recurring->subscription_hash)->first();
                $hireSubscriptionData = [
                    'status' => 4
                ];
                $hiredSubscription->fill($hireSubscriptionData);
                $hiredSubscription->save();

                $recurring->status = 5;
                $recurring->save();
            }
        }

        /*foreach ($recurrings as $recurring) {
            $postback = Postback::where('subscription_id', '=', $recurring->payment_code)
                ->latest()->first();
            $payload = json_decode($postback->payload, true);
            if($payload['current_status'] == 'waiting_payment') {
                $recurring->status = 3;
                $recurring->save();
                $check = Recurring::where('subscription_hash', '=', $recurring->subscription_hash)
                    ->whereNull('payment_code')
                    ->where('status', '=', 0)
                    ->first();
                if($check) {
                    $check->delete();
                }
            }
        }*/
    }

    /**
     * @param $date
     * @param $periodicity
     * @return string
     */
    public function dueDate($date, $periodicity)
    {
        switch ($periodicity) {
            case 30:
                $nextDueDate = Carbon::parse($date)->addMonth();
                break;
            case 90:
                $nextDueDate = Carbon::parse($date)->addMonth(3);
                break;
            case 180:
                $nextDueDate = Carbon::parse($date)->addMonth(6);
                break;
            case 365:
                $nextDueDate = Carbon::parse($date)->addYear();
                break;
        }
        return $nextDueDate->toDateString();
    }

    /**
     * @param $dueDate
     * @return string
     */
    public function nextAttemptDate($dueDate)
    {
        $nextAttempt = Carbon::parse($dueDate);
        $today = Carbon::now();
        if ($nextAttempt < $today) {
            $nextAttempt = $today->addDay(2);
        }
        return $nextAttempt->toDateString();
    }

    /**
     * @param $nextAttemptDate
     * @return string
     */
    public function increaseNextAttemptDate($nextAttemptDate)
    {
        $nextAttemptDate = Carbon::parse($nextAttemptDate)->addDay();
        return $nextAttemptDate->toDateString();
    }

    /**
     * @param $dueDate
     * @param $attemptDate
     * @return int
     */
    public function calculateAttempts($dueDate, $attemptDate)
    {
        $dueDate = Carbon::parse($dueDate);
        $attemptDate = Carbon::parse($attemptDate);
        //$diff = $dueDate->diff($attemptDate)->d + 1;
        $diff = $dueDate->diffInDays($attemptDate) + 1;
        return $diff;
    }
}