walletservice/app/Http/Controllers/TransactionController.php

<?php

namespace App\Http\Controllers;

use App\Models\AgentPlus;
use App\Models\CodeGenerer;
use App\Models\ConfigWallet;
use App\Models\NetworksAgent;
use App\Models\Wallet;
use App\Models\WalletAgent;
use App\Models\WalletTransaction;
use Illuminate\Http\Request;
use Illuminate\Http\Response;

class TransactionController extends Controller
{

    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }

    public function add(Request $request)
    {
        $transaction = new WalletTransaction;
        $this->validate($request, $transaction->rules());

        $walletAgent = Wallet::findOrFail($request->get('id_wallet'));
        $network_agent = NetworksAgent::findOrFail($walletAgent->id_networkAgent);
        // Configuratrion du wallet
        $config = ConfigWallet::where('id_network', $network_agent->network_id)->firstOrFail();

        // Recuperation des wallets hyperviseur et superviseur
        $codeGenerer = CodeGenerer::findOrFail($network_agent->codeGenerer_id);
        $superviseur = AgentPlus::where('code_membre', $codeGenerer->code_parrain)->firstOrFail();
        $hyperviseur = AgentPlus::where('code_membre', $superviseur->code_parrain)->firstOrFail();

        $wallet_agent_sup = WalletAgent::where('agent_id', $superviseur->id)->firstOrFail();
        $wallet_agent_hyp = WalletAgent::where('agent_id', $hyperviseur->id)->firstOrFail();
        $walletSuperviseur = Wallet::findOrFail($wallet_agent_sup->wallet_id);
        $walletHyperviseur = Wallet::findOrFail($wallet_agent_hyp->wallet_id);

        $data = $request->all();
        if (isset($request->cvv) && !is_numeric($request->cvv))
            return $this->errorResponse('errors.invalid_cvv');

        $data['expiration_date'] = \DateTime::createFromFormat('m/y', $request->expiration_date);
        if(!$data['expiration_date'])
            $data['expiration_date'] = new \DateTime();
        $transaction->fill($data);

        $client = new \GuzzleHttp\Client([
            'base_uri' => env('VISA_API_URL'),
            'auth'=>[env('VISA_API_USERNAME') , env('VISA_API_PASSWORD')]
        ]);
        // Procedure de depot d'argent
        if ($transaction->type == 'credit') {
            $frais = $transaction->montant * $config->taux_com_client_depot / 100;

            //Requete vers la banque
            // 1 ---> Emmètre via API sécurisé SSL une requête de débit de notre
            //compte marchand la valeur égale au $montantDepot( montant de la
            //transaction – la frais calculé en % - frais minimum fixe du
            //dépôt client) et créditer sa carte visa de cette valeur
            $montantDepot = $transaction->montant - $frais - $config->frais_min_banque_depot;

            $body['amount'] = $montantDepot;
            $body['card_number'] = $transaction->numCarte;
            $body['cvv'] = $request->cvv;
            $body['expiry_date'] = $data['expiration_date']->format('Y-m');
            // Verification faites au niveau du frontend
//               if($walletAgent->balance_princ >= ($transaction->montant + $frais + $config->frais_min_banque_depot)){

            $code = 200;
            //  API non disponible pour l'instant
//            if($request->facade == 'front'){
//                $response = $client->post('fund-transfer-api/v1/transaction/push', ['json' => $body]);
//                $code = $response->getStatusCode();
//            }

            if ($code == 200) {

                $banqueCommission = floatval($frais * $config->part_banque_depot / 100);
                $transaction->commission_banque = $banqueCommission;
                // 2---> Emmètre via API sécurisé SSL une requête de débit de notre
                //compte marchand du (Part de la banque partenaire en %
                //pour le dépôtqui s’applique sur les frais minimum) et créditer
                //le compte des opérations défini avec notre banque
                //partenaire

                $walletAgent->balance_princ -= $transaction->montant;

                $agentCommission = floatval($frais * $config->taux_com_ag_depot / 100);
                $superviseurCommission = floatval($frais * $config->taux_com_sup_depot / 100);
                $hyperviseurCommission = $frais - $superviseurCommission - $agentCommission - $banqueCommission;

                $walletAgent->balance_com += $agentCommission;
                $walletSuperviseur->balance_com += $superviseurCommission;
                $walletHyperviseur->balance_com += $hyperviseurCommission;

                $transaction->id_wallet_sup = $walletSuperviseur->id;
                $transaction->commission_sup = $superviseurCommission;
                $transaction->id_wallet_hyp = $walletHyperviseur->id;
                $transaction->commission_hyp = $hyperviseurCommission;
                $transaction->commission_ag = $agentCommission;
            }else{
                return $this->errorResponse(trans('errors.visa_api_failed'),Response::HTTP_INTERNAL_SERVER_ERROR);
            }

//               }else{
//                   return $this->errorResponse('Solde agent inferieur au montant de depot + frais + frais minimun de depot de la banque', Response::HTTP_BAD_REQUEST);
//               }

            // Procedure de retrait d'argent
        } elseif ($transaction->type == 'debit') {
            // 12-05-20: Modif de Mr Manga : Le montant de la transaction c'est le montant de retrait sans les frais
            //Bloquer le retrait
            return $this->errorResponse(trans('errors.service_unavailable'), Response::HTTP_BAD_REQUEST);
            $frais = $transaction->montant * $config->taux_com_client_retrait / 100;

            //Requete vers la banque
            // 1 ---> Emmètre via API sécurisé SSL une requête de retrait du
            //(montant de la transaction + frais de transaction) pour débiter
            //sa carte et créditer notre compte marchand
            $montantRetrait = $transaction->montant + $frais;

            $body['amount'] = $montantRetrait;
            $body['card_number'] = $transaction->numCarte;
            $body['cvv'] = $request->cvv;
            $body['expiry_date'] = $data['expiration_date']->format('Y-m');

            $code = 200;
            if($request->facade == 'front'){
                $response = $client->post('fund-transfer-api/v1/transaction/pull', ['json' => $body]);
                $code = $response->getStatusCode();
            }

            if($code == 200) {

                $banqueCommission = floatval($transaction->montant * $config->part_banque_retrait / 100);
                $transaction->commission_banque = $banqueCommission;
                // 2---> Emmètre via API sécurisé SSL une requête de débit de notre
                //compte marchand du (montant de la transaction multiplié
                //par la Part de la banque partenaire en % ) et créditer le
                //compte des opérations défini avec notre banque partenaire

                $walletAgent->balance_princ += $transaction->montant;

                $agentCommission=floatval($transaction->montant*$config->taux_com_ag_retrait / 100);
                $superviseurCommission=floatval($transaction->montant*$config->taux_com_sup_retrait / 100);
                $hyperviseurCommission = $frais - $superviseurCommission - $agentCommission - $banqueCommission;

//                dd(array($hyperviseurCommission ,$superviseurCommission));
                $walletAgent->balance_com += $agentCommission;
                $walletSuperviseur->balance_com += $superviseurCommission;
                $walletHyperviseur->balance_com += $hyperviseurCommission;

                $transaction->id_wallet_sup = $walletSuperviseur->id;
                $transaction->commission_sup = $superviseurCommission;
                $transaction->id_wallet_hyp = $walletHyperviseur->id;
                $transaction->commission_hyp = $hyperviseurCommission;
                $transaction->commission_ag = $agentCommission;
            }else{
                return $this->errorResponse(trans('errors.visa_api_failed'),Response::HTTP_INTERNAL_SERVER_ERROR);
            }

        }

        $transaction->date = $this->getCurrentTime($walletAgent->networks_agent->network->country_id);
        $transaction->statut = 1;
        $walletAgent->save();
        $walletSuperviseur->save();
        $walletHyperviseur->save();
        $transaction->save();
        return $this->successResponse(trans('messages.successful_transaction'));
    }

    public function lastTransactions($id_wallet)
    {
//        $transactions = WalletTransaction::where('id_wallet',$id_wallet)->orderBy('date','desc')->limit(10)
//            ->get(['type' ,DB::raw('\'wallet\' as source'),  'montant' ,'numCarte AS destinataire' , 'date', 'id']);
        $transactions = WalletTransaction::where('id_wallet', $id_wallet)->where('canceled', '0')->where('deleted', '0')->orderBy('date', 'desc')->limit(10)
            ->get(['type as operation', 'montant', 'numCarte AS destinataire', 'date', 'id', 'commission_banque', 'commission_ag',
                'commission_sup', 'commission_hyp']);
        foreach ($transactions as $trans){
            $trans->frais = $trans->commission_banque + $trans->commission_sup + $trans->commission_ag + $trans->commission_hyp;
            $trans->montant_net_init = $trans->montant - $trans->frais;
            $trans->montant_net_final = null;
            $trans->init_country = null;
            $trans->final_country = null;
            $trans->reseau_payeur =  null;
            $trans->id_transaction =  null;
            $trans->emetteur = null;
            unset($trans->commission_banque, $trans->commission_sup,$trans->commission_ag,$trans->commission_hyp);
        }
        return $this->successResponse($transactions);
    }

    public function calculateCommission(Request $request)
    {
        $rules = [
            'id_wallet' => 'required|integer|min:1',
            'montant' => 'required|numeric|min:0|not_in:0',
            'type' => 'required|in:credit,debit',
        ];

        $this->validate($request, $rules);

        $walletAgent = Wallet::findOrFail($request->get('id_wallet'));
        $network_agent = NetworksAgent::findOrFail($walletAgent->id_networkAgent);
        // Configuratrion du wallet
        $config = ConfigWallet::where('id_network', $network_agent->network_id)->firstOrFail();
        $commission = null;
        if ($request->type == 'credit') {
            //Depot
            $commission = ($request->montant * $config->taux_com_client_depot / 100) + $config->frais_min_banque_depot;
            $data['montant_calcule'] = $request->montant - $commission;
        } elseif ($request->type == 'debit') {
            // Retrait
            $commission = $request->montant * $config->taux_com_client_retrait / 100;
            $data['montant_calcule'] = $request->montant + $commission;
        }

        $data['commission'] = $commission;
        return $this->successResponse($data);
    }

    public function cancel($id_transaction)
    {
        $transaction = WalletTransaction::findOrFail($id_transaction);
        $transactionInverse = new WalletTransaction;
        $transactionInverse->date = $this->getCurrentTime($transaction->wallet->networks_agent->network->country_id);
        $transactionInverse->statut = $transaction->statut;
        $transactionInverse->montant =  -$transaction->montant;
        $transactionInverse->numCarte = $transaction->numCarte;
        $transactionInverse->id_wallet = $transaction->id_wallet;
        $transactionInverse->id_wallet_sup = $transaction->id_wallet_sup;
        $transactionInverse->id_wallet_hyp = $transaction->id_wallet_hyp;
        $transactionInverse->commission_ag =  -$transaction->commission_ag;
        $transactionInverse->commission_sup =  -$transaction->commission_sup;
        $transactionInverse->commission_hyp =  -$transaction->commission_hyp;
        $transactionInverse->commission_banque = -$transaction->commission_banque;
        $transactionInverse->facade = $transaction->facade;
        $transactionInverse->type = $transaction->type;
        $transactionInverse->expiration_date = $transaction->expiration_date;

        $walletAgent = $transaction->wallet;
        $walletSuperviseur = $transaction->wallet_sup;
        $walletHyperviseur = $transaction->wallet_hyp;

        if ($transaction->type == 'credit'){
            //Depot
            $walletAgent->balance_princ += $transaction->montant;
        }elseif ($transaction->type == 'debit'){
            //Retrait
            $walletAgent->balance_princ -= $transaction->montant;
        }

        $walletAgent->balance_com -= $transaction->commission_ag;
        $walletSuperviseur->balance_com -= $transaction->commission_sup;
        $walletHyperviseur->balance_com -= $transaction->commission_hyp;
        $transaction->canceled = 1;

        $walletAgent->save();
        $walletSuperviseur->save();
        $walletHyperviseur->save();
        $transaction->save();
        $transactionInverse->save();
        return $this->successResponse(trans('messages.canceled_transaction'));
    }
}