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;


// We can define the User Scheme here or in our App\User model
/**
 * @OA\Schema(
 *   schema="UserSchema",
 *   title="User Model",
 *   description="User model",
 *   @OA\Property(
 *     property="id", description="ID of the user",
 *     @OA\Schema(type="number", example=1)
 *  ),
 *   @OA\Property(
 *     property="name", description="Name of the user",
 *     @OA\Schema(type="string", example="User Name")
 *  )
 * )
 */
// We can define the request parameter inside the Requests or here

/**
 * @OA\Parameter(
 *   parameter="get_users_request_parameter_limit",
 *   name="limit",
 *   description="Limit the number of results",
 *   in="query",
 *   @OA\Schema(
 *     type="number", default=10
 *   )
 * ),
 */
class TransmittingNetworksController extends Controller
{
    use ApiResponser;
    use Helper;

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

    /**
     * @OA\Get(
     *   path="/users",
     *   summary="Return the list of users",
     *   tags={"Hello"},
     *   @OA\Parameter(ref="#/components/parameters/get_users_request_parameter_limit"),
     *    @OA\Response(
     *      response=200,
     *      description="List of users",
     *      @OA\JsonContent(
     *        @OA\Property(
     *          property="data",
     *          description="List of users",
     *          @OA\Schema(
     *            type="array",
     *            @OA\Items(ref="#/components/schemas/UserSchema")
     *          )
     *        )
     *      )
     *    )
     * )
     */
    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',
            '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("Ce reseau destinataire n'est pas configuré dans notre systeme");

        if ($configRecipient->type != 'ilink')
            return $this->errorResponse("Ce reseau destinataire n'est pas autorise à recevoir des transactions dans notre systeme");

        if (!$configTransmitter)
            return $this->errorResponse("Ce reseau emetteur n'est pas configuré dans notre systeme");

        if ($configTransmitter->type != 'autre')
            return $this->errorResponse("Ce reseau emetteur n'est pas autorise à recevoir des transactions dans notre systeme");

        $transmittingNetwork = TransmittingNetwork::where('id_network', $request->network_emetteur)->where('id_configWallet', $configRecipient->id)->first();
        if (!$transmittingNetwork)
            return $this->errorResponse("Ce reseau n'est pas reconnu comme etant un reseau emetteur du reseau destinataire");


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

        //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 = $request->montant;

        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 = $request->montant_commission;
                $transaction->save();

                $message = trans('messages.wallet_incoming_payment_message',
                    ['amount' => $this->toMoneyWithNetwork($request->montant, $request->id), 'transmitter' => $request->nom_emetteur . ' ' . $request->prenom_emetteur]);

                $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'
                ]);

                $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 = floatval($request->montant_commission * $configRecipient->taux_com_hyp_envoi_cash / 100);

                $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]);

                $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;
    }


}