walletservice/app/Http/Controllers/TransmittingNetworksController.php

<?php

namespace App\Http\Controllers;

use App\Models\ConfigWallet;
use App\Models\Network;
use App\Models\TransmittingNetwork;
use App\Models\User;
use App\Models\Wallet;
use App\Models\WalletAgent;
use App\Models\WalletIlinkTransaction;
use App\Models\WalletsUser;
use App\Traits\ApiResponser;
use App\Traits\Helper;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;


class TransmittingNetworksController extends Controller
{
    use ApiResponser;
    use Helper;

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


    public function index(Request $request)
    {
        $users = User::paginate($request->get("limit", 10));
        return ["data" => $users];
    }

    public function receivePayment(Request $request)
    {
        $this->validate($request, [
            'type' => 'required|integer|in:1,17', // Les types de transactions possibles à recevoir [1,3,17]
            'montant' => 'required|numeric|min:0|not_in:0',
            'frais' => 'required|numeric|min:0|not_in:0',
            'taxe' => 'required|numeric|min:0|not_in:0',
            'part_reseau_emetteur' => 'required|numeric|min:0|not_in:0',
            'part_reseau_payeur' => 'required|numeric|min:0|not_in:0',
            'montant_commission' => 'required|numeric|min:0|not_in:0',
            'network_emetteur' => 'required|numeric|min:0|not_in:0',
            'network_destinataire' => 'required|numeric|min:0|not_in:0',
            'id_transaction_network_emetteur' => 'required',
        ]);

        $configRecipient = ConfigWallet::where('id_network', $request->network_destinataire)->first();
        $configTransmitter = ConfigWallet::where('id_network', $request->network_emetteur)->first();

        if (!$configRecipient)
            return $this->errorResponse(trans('errors.recipient_network_not_configured'));

        if ($configRecipient->type != 'ilink')
            return $this->errorResponse(trans('errors.recipient_network_not_authorized'));

        if (!$configTransmitter)
            return $this->errorResponse(trans('errors.transmitter_network_not_configured'));

        if ($configTransmitter->type != 'autre')
            return $this->errorResponse(trans('errors.transmitter_network_not_authorized'));

        $transmittingNetwork = TransmittingNetwork::where('id_network', $request->network_emetteur)->where('id_configWallet', $configRecipient->id)->first();
        if (!$transmittingNetwork)
            return $this->errorResponse(trans('errors.transmitter_network_not_recognized'));


        $transaction = new WalletIlinkTransaction();
        $transaction->fill($request->all());
        $transaction->id_transaction = $this->getTransactionID();
        $transaction->from_network_emetteur = true;

        //Hyperviseur destinataire
        $hyperviseurDestinataire = WalletAgent::where('category', 'hyper')->where('network_id', $request->network_destinataire)->firstOrFail();
        $walletHyper = Wallet::findOrFail($hyperviseurDestinataire->wallet_id);
        $transaction->id_wallet_hyp = $walletHyper->id;
        $finalNetwork = Network::findOrFail($request->network_destinataire);
        $transaction->final_country = $finalNetwork->country->id;
        $initNetwork = Network::findOrFail($request->network_emetteur);
        $transaction->init_country = $initNetwork->country->id;
        $transaction->montant_net = $transaction->montant_net_final_country = $request->montant;
        $transaction->part_reseau_payeur_final_country = $transaction->part_reseau_payeur;
        $transaction->status_reseau_payeur = 'EN_COURS';

        switch ($request->type) {
            case 1:
                $this->validate($request, [
                    'id_destinataire' => 'required',
                    'nom_emetteur' => 'required',
                    'prenom_emetteur' => 'required',
                    'email_emetteur' => 'required',
                    'type_document_emetteur' => 'required',
                    'id_document_emetteur' => 'required',
                    'id_emetteur' => 'required',
                ]);

                $destinataire = User::where('user_code', $request->id_destinataire)->first();
                if ($destinataire) { // Si c'est un wallet ilink
                    if ($destinataire->network->country->id == $finalNetwork->country->id) {
                        $walletDestinataire = WalletsUser::where('idUser', $destinataire->id)->firstOrFail();
                        $walletDestinataire->balance += $request->montant;
                        $transaction->id_wallet_user = $walletDestinataire->id;
                        $walletDestinataire->save();
                    } else {
                        return $this->errorResponse(trans('errors.wallet_country_not_match', ['country' => $finalNetwork->country->name]));
                    }
                } else {
                    return $this->errorResponse(trans('errors.wallet_not_defined'));
                }


                $walletHyper->balance_com += $request->montant_commission;
                $walletHyper->save();

                $transmittingNetwork->balance_compensation += $request->montant;
                $transmittingNetwork->balance_com += $request->montant_commission;
                $transmittingNetwork->save();

                $transaction->commission_hyp = $transaction->commission_hyp_final_country = $request->montant_commission;
                $transaction->status_reseau_payeur = 'TRAITEE';
                $transaction->date = $this->getCurrentTimeByCountryCode($initNetwork->country->code_country);
                $transaction->save();

                $message = trans('messages.wallet_incoming_payment_message',
                    ['id_transaction' => $transaction->id_transaction, 'amount' => $this->toMoneyWithNetwork($request->montant, $request->id),
                        'sender_name' => $request->nom_emetteur . ' ' . $request->prenom_emetteur, 'init_country' => $initNetwork->country->name, 'sender_code' => $request->id_emetteur,
                        'final_country' => $finalNetwork->country->name, 'network' => $initNetwork->name, 'receiver_code' => $request->id_destinataire]);

                $this->sendMail($destinataire->email, trans('messages.wallet_incoming_payment'), $message);
                return $this->successResponse(trans('messages.success_treated_demand'));
            case 17:
                $this->validate($request, [
                    'id_emetteur' => 'required',
                    'nom_emetteur' => 'required',
                    'prenom_emetteur' => 'required',
                    'type_document_emetteur' => 'required',
                    'id_document_emetteur' => 'required',
                    'email_emetteur' => 'required',
                    'nom_destinataire' => 'required',
                    'prenom_destinataire' => 'required',
                    'type_document_destinataire' => 'required',
                    'id_document_destinataire' => 'required',
                    'email_destinataire' => 'required',
                    'code_retrait' => 'required|size:16'
                ]);

                $hash = $this->hashSSHA($request->code_retrait);
                $transaction->encrypted_code_retrait = $hash['encrypted'];
                $transaction->code_retrait_salt = $hash['salt'];
                $transaction->status_retrait = false;

                $transaction->commission_ag = floatval($request->montant_commission * $configRecipient->taux_com_ag_envoi_cash / 100);
                $transaction->commission_sup = floatval($request->montant_commission * $configRecipient->taux_com_sup_envoi_cash / 100);
                $transaction->commission_hyp = $transaction->commission_hyp_final_country = floatval($request->montant_commission * $configRecipient->taux_com_hyp_envoi_cash / 100);
                $transaction->date = $this->getCurrentTimeByCountryCode($initNetwork->country->code_country);
                $transaction->save();

                $message = trans('messages.cash_incoming_payment_message',
                    ['amount' => $this->toMoneyWithNetwork($request->montant, $request->id), 'id_transaction' => $transaction->id_transaction,
                        'sender_name' => $request->nom_emetteur . ' ' . $request->prenom_emetteur, 'receiver_name' => $request->nom_destinataire . ' ' . $request->prenom_destinataire,
                        'code' => wordwrap($request->code_retrait, 4, ' ', true), 'init_country' => $initNetwork->country->name,
                        'final_country' => $finalNetwork->country->name, 'network' => $initNetwork->name]);

                $this->sendMail($request->email_destinataire, trans('messages.cash_incoming_payment'), $message);
                return $this->successResponse(trans('messages.success_treated_demand'));
                break;
            case 18:
                return $this->successResponse(trans('messages.success_treated_demand'));
                break;
        }
    }

    private function getTransactionID()
    {
        do {
            $code = $this->generateTransactionCode();
            $result = collect(DB::select('SELECT * FROM wallet_ilink_transaction WHERE id_transaction = :code', ['code' => $code]));
            $codeCorrect = sizeof($result) < 0;
        } while ($codeCorrect);
        return $code;
    }


}