eagle.ead.lmsestudio.com.br

UnknownSec Bypass 403

: /mnt/lmsestudio-instance-vol002/lms_0fbd48a558b0/app/System/ [ drwxr-xr-x ]
name : PlanValidator.php
 <?php namespace EstudioLMS\System;

use EstudioLMS\Repositories\Config\SaasConfigInterface;
use EstudioLMS\Repositories\Environment\HiredCourseRepository;
use Symfony\Component\HttpFoundation\Session\SessionInterface;

/**
 * Class PlanValidator
 * @package EstudioLMS\System
 */
class PlanValidator
{
    /**
     * @var SaasConfigInterface
     */
    private $saasConfig;
    /**
     * @var HelperClass
     */
    private $helperClass;
    /**
     * @var Session
     */
    private $session;
    /**
     * @var HiredCourseRepository
     */
    private $hiredCourseRepository;

    /**
     * PlanValidator constructor.
     * @param HelperClass $helperClass
     * @param SaasConfigInterface $saasConfig
     * @param SessionInterface $session
     * @param HiredCourseRepository $hiredCourseRepository
     */
    public function __construct(
        HelperClass $helperClass,
        SaasConfigInterface $saasConfig,
        SessionInterface $session,
        HiredCourseRepository $hiredCourseRepository
    ) {
        $this->helperClass = $helperClass;
        $this->saasConfig = $saasConfig;
        $this->session = $session;
        $this->hiredCourseRepository = $hiredCourseRepository;
    }

    /**
     *
     */
    public function getPlanLimits()
    {
        $connData = $this->saasConfig->first();
        if ($this->helperClass->setDatabaseConfig('adm', $connData)) {
            $select = [
                'customers.*'
            ];

            $planSelect = [
                'plans.id as plan_plan_id',
                'plans.name as plan_name',
                'plans.description as plan_description',
                'plans.server_id as plan_server_id',
                'plans.dataserver_id as plan_dataserver_id',
                'plans.processors as plan_processors',
                'plans.memory as plan_memory',
                'plans.users_limit as plan_users_limit',
                'plans.storage as plan_storage',
                'plans.data_transfer as plan_data_transfer',
                'plans.price as plan_price'
            ];

            $serverSelect = [
                'servers.host as serverHost',
                'servers.absolute_path as serverPath',
                'servers.root_user as serverUser',
            ];

            $dataserverSelect = [
                'dataservers.host as dataserverHost',
                'dataservers.root_user as dataserverUser'
            ];

            $select = array_merge($select, $planSelect, $serverSelect, $dataserverSelect);

            $customer = \DB::connection('adm')->table('customers')
                ->join('plans', 'plan_id', '=', 'plans.id')
                ->join('servers', 'customers.server_id', '=', 'servers.id')
                ->join('dataservers', 'customers.dataserver_id', '=', 'dataservers.id')
                ->where('tenant_id', '=', \Config::get('config.tenant_id'))
                ->first($select);

            $customer = json_decode(json_encode($customer), true);

            if ($this->session->has('planLimite')) {
                $this->session->forget('planLimite');
            }

            $this->session->set('planLimite', $customer);
            $this->customerStats();
            $bankSlip = $this->subscriptionStatus($customer['id']);
            $this->session->set('bankSlip', $bankSlip);
        }
    }

    /**
     * @param $customerId
     * @return array
     */
    public function subscriptionStatus($customerId)
    {
        $subscription = \DB::connection('adm')->table('subscriptions')
            ->join('subscription_statuses', 'subscription_status_id', '=', 'subscription_statuses.id')
            ->where('customer_id', '=', $customerId)
            ->whereIn('subscription_status_id', [2, 3, 4])
            ->first(['subscriptions.*', 'subscription_statuses.description']);

        if (count($subscription) > 0) {
            if ($subscription->payment_method == 'credit_card') {
                return [
                    'type' => 'credit_card',
                    'subscription_status' => $subscription->description
                ];
            }

            $postback = \DB::connection('adm')->table('postbacks')
                ->where('subscription_id', '=', $subscription->subscription_id)
                ->where('payload', 'like', '%"event": "subscription_status_changed"%')
                ->latest()->first();

            if (count($postback) > 0) {
                $json = json_decode($postback->payload);
                return [
                    'type' => 'boleto',
                    'bank_slip' => $json->subscription->current_transaction->boleto_url,
                    'bar_code' => $json->subscription->current_transaction->boleto_barcode,
                    'subscription_status' => $subscription->description
                ];
            }
        }

        return [
            'type' => 'free'
        ];
    }

    public function checkPlanLimits()
    {

    }

    /**
     * @return mixed
     */
    public function customerStats()
    {
        $activeUsers = $this->hiredCourseRepository->activeUsers();
        if ($this->session->has('planLimite')) {
            $planLimite = $this->session->get('planLimite');
            $storageSize = $this->helperClass->storageSize();

            $planLimite['activeUsers'] = $activeUsers;
            $planLimite['storageSize'] = $storageSize;

            $this->session->forget('planLimite');
            $this->session->set('planLimite', $planLimite);
        }

        return $planLimite;
    }
}