xXx

Hexid M1n1 5h3ll MobiLe

var/www/phalcon/app/modules/site/controllers/_[ Not.Writable ]

File://var/www/phalcon/app/modules/site/controllers/PagamentoController.php

<?php

namespace App\Modules\Site\Controllers;

use App\Library\CustomPaypal\Util as PaypalUtil;
use App\Models\Moeda;
use App\Models\Pacote;
use App\Models\Plano;
use App\Models\Usuario;
use App\Models\UsuarioCompraPacote;
use App\Models\UsuarioPaypalRetorno;

/**
 *
 */
class PagamentoController extends ControllerBase
{

    private $baseUrl = "https://www.tripppin.com/";
    

    public function beforeExecuteRoute(\Phalcon\Mvc\Dispatcher $dispatcher)
    {
        $this->baseUrl = $this->config->application->baseUri;
        return parent::beforeExecuteRoute($dispatcher);
    }

    public function testeAction():void 
    {
        $this->flash->success("Teste de sucesso!");
        $this->flash->error("Teste de erro!");
        $this->response->redirect("pagamento/index");
    }

    /**
     * Exibe a parte de pagamentos do usuário.
     * 
     * @author Hugo Ferreira da Silva <hufersil@gmail.com>
     * @since  2019-04-25
     * @return [type]     [description]
     */
    public function indexAction()
    {
        $user = Usuario::findFirst($this->getUsuario()->getCodusuario());

        $pacotes = Pacote::find(["ativo = 1", "order" => "ordem"]);
        $planos = Plano::find(["ativo = 1", "order" => "ordem"]);
        $moedas = Moeda::find(["order" => "nome"]);
        $planoAtual = null;
        $codusuario = $user->getCodusuario();
        $inscricaoAtiva = UsuarioPaypalRetorno::getUsuarioInscricao($codusuario, UsuarioPaypalRetorno::STATUS_ATIVO);

        if ($user->getCodplano()) {
            $planoAtual = Plano::findFirst($user->getCodplano());
        }

        $diasRestantes = 0;

        if ($user->temAcessoPremium()) {
            $dataFim = new \DateTime($user->getDataFimPlano());
            $diff = $dataFim->diff(new \DateTime());
            $diasRestantes = $diff->days ?: 1;
        }

        $this->view->setVars([
            "usuario" => $user,
            "planoAtivo" => $planoAtual,
            "planos" => $planos,
            "pacotes" => $pacotes,
            "moedas" => $moedas,
            "diasRestantes" => $diasRestantes,
            "inscricaoAtiva" => $inscricaoAtiva,
        ]);
    }

    /**
     * Exibe o conteúdo do popup de moedas.
     * 
     * @author Hugo Ferreira da Silva <hufersil@gmail.com>
     * @since  2019-05-02
     * @return [type]     [description]
     */
    public function helpMoedasAction()
    {
    }

    /**
     * Inicia a compra de um pacote.
     * 
     * @author Hugo Ferreira da Silva <hufersil@gmail.com>
     * @since  2019-04-28
     * @param  integer    $codpacote [description]
     * @return [type]                [description]
     */
    public function comprar_pacoteAction($codpacote = -1)
    {
        $pacote = Pacote::findFirst(intval($codpacote));

        if (!$pacote) {
            $this->flash->error($this->util->translate("pacote_nao_encontrado"));
            $this->response->redirect("pagamento/index");
            return;
        }

        $user = $this->getUsuario();

        $credencial = $this->paypalCredentials;
        $endpoint = "payments/payment";

        $userPacote = new UsuarioCompraPacote();
        $userPacote->setCodusuario($user->getCodusuario());
        $userPacote->setCodpacote($pacote->getCodpacote());
        $userPacote->setDataPedido(new \DateTime());
        $userPacote->setHash($this->util->hash());
        $userPacote->setValor($pacote->getValor());
        $userPacote->setStatus(UsuarioCompraPacote::STATUS_PENDENTE);
        $userPacote->save();

        $request = [
            "intent" => "sale",
            "payer" => [
                "payment_method" => "paypal"
            ],
            "transactions" => [[
                "amount" => [
                    "total" => $pacote->getValor(),
                    "currency" => "BRL",
                ],
                "description" => $pacote->getNome(),
                "custom" => "PACOTE-" . $pacote->getCodpacote(),
                "invoice_number" => $userPacote->getHash(),
                "payment_options" => [
                    "allowed_payment_method" => "INSTANT_FUNDING_SOURCE"
                ],
                "soft_descriptor" => "TRIPPPIN-" . $pacote->getCodpacote(),
                "item_list" => [
                    "items" => [
                        [
                            "name" => $pacote->getNome(),
                            "description" => $pacote->getNome(),
                            "quantity" => "1",
                            "price" => $pacote->getValor(),
                            "tax" => "0",
                            "sku" => $pacote->getCodpacote(),
                            "currency" => "BRL"
                        ]
                    ]
                ]
            ]],
            "note_to_payer" => "Contact us for any questions on your order.",
            "redirect_urls" => [
                "return_url" => $this->baseUrl . "pagamento/paypal_retorno_pacote?hash=" . $userPacote->getHash(),
                "cancel_url" => $this->baseUrl . "pagamento/paypal_retorno_pacote"
            ]
        ];

        try {
            $pagamento = PaypalUtil::doPost($credencial, $endpoint, $request);

            $link = from($pagamento->links)
                ->where('$v->rel == "approval_url"')
                ->toArray();

            if (empty($link)) {
                throw new \Exception("Não pode completar o pagamento - link não encontrado");
            }

            $first = reset($link);

            $this->response->redirect($first->href);
        } catch (\Exception $ex) {
            $this->flash->error($ex->getMessage());
            $this->response->redirect("pagamento/index");
        }
    }

    /**
     * Método chamado pelo paypal após a compra de um pacote avulso.
     * 
     * @author Hugo Ferreira da Silva <hufersil@gmail.com>
     * @since  2019-04-28
     * @return [type]     [description]
     */
    public function paypal_retorno_pacoteAction()
    {
        $this->view->disable();

        $paymentId = $this->request->get("paymentId");
        $token = $this->request->get("token");
        $hash = $this->request->get("hash");
        $payerID = $this->request->get("PayerID");

        if ($paymentId && $hash) {
            $credencial = $this->paypalCredentials;
            $endpoint = "payments/payment/$paymentId";

            // pegamos os dados do pedido no paypal e no tripppin.
            $resposta = PaypalUtil::doGet($credencial, $endpoint, null);
            $numeroPedido = $resposta->transactions[0]->invoice_number;
            $pedido = UsuarioCompraPacote::findFirstByHash($numeroPedido);

            if ($resposta->state == "created") {
                // executamos o pagamento no paypal
                $request = ["payer_id" => $payerID];
                $endpoint .= "/execute";

                try {
                    $resposta = PaypalUtil::doPost($credencial, $endpoint, $request);

                    if (!empty($resposta->state) && $resposta->state == 'approved') {
                        $pedido->setStatus(UsuarioCompraPacote::STATUS_APROVADO);
                        $pedido->setPaypalPaymentId($paymentId);
                        $pedido->setPaypalPayerId($payerID);
                        $pedido->save();

                        $pedido->creditarDadosPacote();

                        $this->flash->success($this->util->translate("pacote_comprado_com_sucesso"));
                    }
                } catch (\Exception $ex) {
                    $this->flash->error("Falha ao executar pagamento - " . $ex->getMessage());
                }
            } else {
                $this->flash->error($this->util->translate("status_invalido") . " - " . $resposta->state);
            }
        } else {
            $this->flash->error($this->util->translate("pagamento_nao_aprovado"));
        }

        $this->response->redirect("pagamento/index");
    }

    /**
     * Exibe a tela de confirmação de cancelamento do plano.
     * 
     * @author Hugo Ferreira da Silva <hufersil@gmail.com>
     * @since  2019-04-28
     * @return [type]     [description]
     */
    public function confirmacao_cancelamentoAction()
    {
        $user = Usuario::findFirst($this->getUsuario()->getCodusuario());

        $this->view->setMainView('');
        $planoAtual = null;

        if ($user->temAcessoPremium()) {
            $planoAtual = Plano::findFirst($user->getCodplano());
        }

        $this->view->setVar("planoAtual", $planoAtual);
    }

    /**
     * Exibe os detalhes do plano.
     * 
     * @author Hugo Ferreira da Silva <hufersil@gmail.com>
     * @since  2019-04-27
     * @return [type]     [description]
     */
    public function detalhes_planoAction()
    {
        $user = Usuario::findFirst($this->getUsuario()->getCodusuario());

        $this->view->setMainView('');
        $codplano = $this->request->getPost("codplano", "int");
        $planoEscolhido = Plano::findFirst($codplano);
        $planoAtual = null;
        $id = $user->getCodusuario();
        $inscricaoAtiva = UsuarioPaypalRetorno::getUsuarioInscricao($id, UsuarioPaypalRetorno::STATUS_ATIVO);

        if ($user->temAcessoPremium() && $inscricaoAtiva) {
            $planoAtual = Plano::findFirst($user->getCodplano());
        }

        $this->view->setVar("planoEscolhido", $planoEscolhido);
        $this->view->setVar("planoAtual", $planoAtual);
        $this->view->setVar("inscricaoAtiva", $inscricaoAtiva);
    }

    /**
     * Escolhe o plano para enviar ao paypal.
     * 
     * @author Hugo Ferreira da Silva <hufersil@gmail.com>
     * @since  2019-04-25
     * @return [type]     [description]
     */
    public function escolherPlanoAction($codplano = -1)
    {
        $this->view->disable();

        $this->util->transacao(function () use ($codplano) {
            // antes de escolher o plano, temos que cancelar a 
            // inscrição atual do usuário, se houver.
            try {
                $this->getUsuario()->cancelarInscricaoAtual();
            } catch (\Exception $ex) {
                $this->flash->error($ex->getMessage());
                $this->response->redirect("pagamento/index");
                return;
            }

            $client = $this->paypalClient;
            $endpoint = "v1/billing/subscriptions";
            $plano = Plano::findFirst(intval($codplano));

            if (!$plano) {
                $this->flash->error("Código de plano inválido");
                $this->response->redirect("pagamento/index");
                return;
            }

            $user = $this->getUsuario();

            $subscription = [
                "plan_id" => $plano->getPaypalPlanId(),
                //"start_time" => (new \DateTime('+10 hour'))->format("Y-m-d\TH:i:s\Z"),
                "quantity" => 1,
                "auto_renewal" => true,
                "subscriber" => [
                    "name" => [
                        "given_name" => $user->getNome(),
                        "surname" => $user->getSobrenome()
                    ],
                    "email_address" => $user->getEmail()
                ],
                "application_context" => [
                    "return_url" => $this->baseUrl . "pagamento/paypal_retorno",
                    "cancel_url" => $this->baseUrl . "pagamento/paypal_retorno",
                    "brand_name" => "Tripppin",
                    "locale" => "en-US",
                    "payment_method" => [
                        "payer_selected" => "PAYPAL",
                        "payee_preferred" => "IMMEDIATE_PAYMENT_REQUIRED"
                    ]
                ]
            ];

            try {
                $res = json_decode($client->post($endpoint, ["json" => $subscription])->getBody()->getContents());
                $links = array_filter($res->links, fn ($item) => $item->rel == 'approve');

                if (empty($links)) {
                    throw new \Exception("nenhum link de aprovação encontrado");
                }

                // aqui já temos que criar um "de-para" da inscrição criada
                $paypalInscricao = new UsuarioPaypalRetorno();
                $paypalInscricao->setCodusuario($user->getCodusuario());
                $paypalInscricao->setSubscriptionId($res->id);
                $paypalInscricao->setBaToken(strtoupper(uniqid("TOKEN-")));
                $paypalInscricao->setToken(strtoupper(uniqid("TOKEN-")));
                $paypalInscricao->setDataHora(new \DateTime());
                $paypalInscricao->setStatus(UsuarioPaypalRetorno::STATUS_PENDENTE);
                $paypalInscricao->setCodplano($codplano);
                if(!$paypalInscricao->save()) {
                    print_r($paypalInscricao->getMessages());
                    exit;
                }

                $this->response->redirect($links[0]->href);
            } catch (\Exception $ex) {
                $this->flash->error("Não foi possível criar o pagamento. Tente novamente mais tarde - " . $ex->getMessage() . "($endpoint)");
                $this->response->redirect("pagamento/index");
            }
        });
    }

    /**
     * Cancela a inscrição atual do usuário.
     *
     * Só cancelamos no paypal, mantemos o periodo ativo,
     * pois em teoria já foi debitado.
     * 
     * @author Hugo Ferreira da Silva <hufersil@gmail.com>
     * @since  2019-04-28
     * @return [type]     [description]
     */
    public function cancelarInscricaoAction()
    {
        try {
            $this->getUsuario()->cancelarInscricaoAtual();
            $this->flash->success($this->util->translate("inscricao_cancelada_com_sucesso"));
        } catch (\Exception $ex) {
            $this->flash->error("Falha ao cancelar inscrição - " . $ex->getMessage());
        }

        $this->response->redirect("pagamento/index");
    }

    /**
     * Processa o retorno do PayPal.
     * 
     * @author Hugo Ferreira da Silva <hufersil@gmail.com>
     * @since  2019-04-23
     * @return [type]     [description]
     */
    public function paypalRetornoAction()
    {
        $this->view->disable();

        $subscriptionId = $this->request->get("subscription_id");
        $baToken = $this->request->get("ba_token");
        $token = $this->request->get("token");

        $qs = "subscription_id=$subscriptionId&ba_token=$baToken&token=$token";

        // if (empty($subscriptionId) || empty($baToken) || empty($token)) {
        if (empty($subscriptionId)) {
            $this->flash->error("Dados insuficientes para o processamento");
            $this->response->redirect("pagamento/index?" . $qs);
            return;
        }

        // vamos gravar o retorno no banco,
        // assim se der problema, temos os dados gravados da tentativa.
        $user = Usuario::findFirst($this->getUsuario()->getCodusuario());

        $retorno = UsuarioPaypalRetorno::findFirstBySubscriptionId($subscriptionId);

        if ($retorno->getStatus() == UsuarioPaypalRetorno::STATUS_PENDENTE) {
            $client = $this->paypalClient;
            $endpoint = "v1/billing/subscriptions/{$subscriptionId}";

            try {
                // $detalhesPlano = PaypalUtil::doGet($credencial, $endpoint, []);
                $detalhesPlano = json_decode($client->get($endpoint)->getBody()->getContents());

                if ($detalhesPlano->status == 'ACTIVE') {
                    $this->util->transacao(function () use ($user, $detalhesPlano, $retorno) {
                        $plano = Plano::findFirstByPaypalPlanId($detalhesPlano->plan_id);
                        if (!$plano) {
                            throw new \Exception("Plano não existe - " . $detalhesPlano->plan_id);
                        }
                        $user->ativarPlano($plano);

                        $retorno->setCodplano($plano->getCodplano());
                        $retorno->setStatus(UsuarioPaypalRetorno::STATUS_ATIVO);
                        $retorno->save();

                        $this->flash->success($this->util->translate("welcome_to_premium_tripppin"));
                        $this->response->redirect("pagamento/index");

                        $this->setUsuario($user);
                    });
                } else {
                    throw new \Exception("status inválido - " . $detalhesPlano->status);
                }
            } catch (\Exception $ex) {
                $this->flash->error("Não foi possível ativar o plano - " . $ex->getMessage());
                $this->response->redirect("pagamento/index?" . $qs);
            }
        } else {
            $this->response->redirect("pagamento/index?" . $qs);
        }
    }
}

Your Access Expired	Date. in : 17-09-2025
Regist : 09-12-2024	Expired : 01-12-2027