walletservice/app/Http/Controllers/NanoCreditController.php

<?php

namespace App\Http\Controllers;

use App\Models\ConfigWallet;
use App\Models\Identification;
use App\Models\Network;
use App\Models\NetworksAgent;
use App\Models\TransfertCommissionTransaction;
use App\Models\UsersDemandesCredit;
use App\Models\UsersGroup;
use App\Models\UsersGroupsDemandesValidation;
use App\Models\Wallet;
use App\Models\WalletsUser;
use App\Models\WalletTransaction;
use App\Traits\ApiResponser;
use App\Traits\Helper;
use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Date;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Mail;

class NanoCreditController extends Controller
{
    use ApiResponser;
    use Helper;

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

    // Gestion des groupes

    public function createGroup(Request $request)
    {
        $group = new UsersGroup();
        $this->validate($request, [
            'id_user' => 'required|integer|min:0|not_in:0',
            'nom' => 'required',
            'code_sponsor1' => 'required',
            'code_sponsor2' => 'required',
            'code_sponsor3' => 'required',
            'password' => 'required',
            'limite_credit' => 'required|numeric|min:0|not_in:0',

        ]);

        $user = User::findOrFail($request->id_user);
        if (!$this->checkPassword($request->password, $user->encrypted_password, $user->salt))
            return $this->errorResponse(trans('messages.incorrect_user_password'));

        $this->checkMyIdentification($request->id_user);

        //Verifier s'il appartient a un groupe
        if (isset($user->group_id))
            return $this->errorResponse(trans('errors.user_belongs_to_group'));

        //Verifier s'il n'est pas sponsor
        if (in_array($user->user_code, [$request->code_sponsor1, $request->code_sponsor2, $request->code_sponsor3]))
            return $this->errorResponse(trans('errors.cannot_be_sponsor'));

        //Verifier l'unicite de chacun des trois sponsors
        if ($this->array_has_dupes([$request->code_sponsor1, $request->code_sponsor2, $request->code_sponsor3]))
            return $this->errorResponse(trans('errors.sponsors_must_be_unique'));

        $init_country = $user->network->country->id;
        $result = ConfigWallet::join('networks', 'networks.id', '=', 'configWallet.id_network')
            ->where('networks.country_id', $init_country)->where('configWallet.type', 'ilink')
            ->select('configWallet.id')->first();
        if ($result) {
            $config = ConfigWallet::findOrFail($result->id);
        } else {
            return $this->errorResponse(trans('errors.no_ilink_network'));
        }

        if (!$config->has_nano_credit)
            return $this->errorResponse(trans('errors.nano_credit_not_available'));
        if ($request->limite_credit > $config->limite_credit_max)
            return $this->errorResponse(trans('errors.credit_limit_is_greater_than_max'));
        if ($request->limite_credit < $config->limite_credit_min)
            return $this->errorResponse(trans('errors.credit_limit_is_less_than_min'));

        $group->fill($request->all());
        // Envoyer des codes sponsors differents
        //Check sponsor 1
        $resp1 = $this->checkSponsorIdentification($request->code_sponsor1, 1, $init_country);

        if ($resp1 instanceof Identification)
            $group->id_sponsor1 = $resp1->id_user;
        else
            return $resp1;

        //Check sponsor 2
        $resp2 = $this->checkSponsorIdentification($request->code_sponsor2, 2, $init_country);
        if ($resp2 instanceof Identification)
            $group->id_sponsor2 = $resp2->id_user;
        else
            return $resp2;

        //Check sponsor 3
        $resp3 = $this->checkSponsorIdentification($request->code_sponsor3, 3, $init_country);
        if ($resp3 instanceof Identification)
            $group->id_sponsor3 = $resp3->id_user;
        else
            return $resp3;

        $group->id_createur = $request->id_user;
        $group->date_creation = new \DateTime();
        $group->nombre_validation = 0;
        $group->actif = false;
        $group->nombre_utilisateurs = 1;
        $group->code_groupe = $this->getGroupID();
        $group->save();
        $user->group_id = $group->id;
        $user->date_adhesion = new \DateTime();
        $user->save();

        $this->sendNotificationToSponsor($group->id, $group->id_sponsor1, $request->code_sponsor1, $user);
        $this->sendNotificationToSponsor($group->id, $group->id_sponsor2, $request->code_sponsor2, $user);
        $this->sendNotificationToSponsor($group->id, $group->id_sponsor3, $request->code_sponsor3, $user);

        return $this->successResponse(trans('messages.successful_user_group_created'));

    }

    public function validateGroupDemand(Request $request)
    {
        $this->validate($request, [
            'type' => 'required|in:creation,suppression',
        ]);

        if ($request->type == 'creation')
            return $this->validateGroupCreationDemand($request);
        if ($request->type == 'suppression')
            return $this->validateDeletingGroupDemand($request);
    }


    private function validateGroupCreationDemand(Request $request)
    {
        $this->validate($request, [
            'id_demande' => 'required|integer|min:0|not_in:0',
            'id_user' => 'required|integer|min:0|not_in:0'
        ]);
        $demande = UsersGroupsDemandesValidation::findOrFail($request->id_demande);
        if ($demande->statut != 0)
            return $this->errorResponse(trans('errors.treated_group_demand'));

        if ($demande->id_sponsor != $request->id_user)
            return $this->errorResponse(trans('errors.not_group_sponsor'));

        $sponsor = User::findOrFail($request->id_user);
        $group = UsersGroup::findOrFail($demande->id_group);

        if ($group->actif)
            return $this->errorResponse(trans('errors.group_already_active'));

        ++$group->nombre_validation;
        ++$group->nombre_utilisateurs;
        if ($group->nombre_validation == 3) {
            $group->actif = true;
            $group->date_activation = new \DateTime();
        }

        $sponsor->group_id = $group->id;
        $sponsor->date_adhesion = new \DateTime();
        $sponsor->save();
        $group->save();
        $demande->statut = true;
        $demande->date_validation = new \DateTime();
        $demande->save();
        // Notififier le createur
        $data = new \stdClass();
        $data->screen = "notificationview";
        $data->data = new \stdClass();;
        $data->data->id = $request->id_demande;
        $this->sendPushNotificationToUser($group->createur->user_code,
            trans('notifications.accepted_group_validation_request', ['name' => $sponsor->lastname . ' ' . $sponsor->firstname]), $data);

        return $this->successResponse(trans_choice('messages.successful_group_validation', 3 - $group->nombre_validation, ['count' => (3 - $group->nombre_validation)]));

    }

    public function cancelGroupDemand(Request $request)
    {
        $this->validate($request, [
            'id_demande' => 'required|integer|min:0|not_in:0',
            'id_user' => 'required|integer|min:0|not_in:0',
            'type' => 'required|in:creation,suppression',
        ]);
        $demande = UsersGroupsDemandesValidation::findOrFail($request->id_demande);
        if ($demande->statut != 0)
            return $this->errorResponse(trans('errors.treated_group_demand'));

        if ($demande->id_sponsor != $request->id_user)
            return $this->errorResponse(trans('errors.not_group_sponsor'));


        $sponsor = User::findOrFail($request->id_user);
        $group = UsersGroup::findOrFail($demande->id_group);

        $demande->statut = 2;
        $demande->date_validation = new \DateTime();
        $demande->save();
        // Notififier le createur
        $data = new \stdClass();
        $data->screen = "notificationview";
        $data->data = new \stdClass();;
        $data->data->id = $request->id_demande;

        if ($request->type == 'creation') {
            $this->sendPushNotificationToUser($group->createur->user_code,
                trans('notifications.refused_group_validation_request', ['name' => $sponsor->lastname . ' ' . $sponsor->firstname]), $data);

            return $this->successResponse(trans('messages.successful_refused_group_validation'));
        }

        if ($request->type == 'suppression') {
            $this->sendPushNotificationToUser($group->createur->user_code,
                trans('notifications.refused_group_deleting_request', ['name' => $sponsor->lastname . ' ' . $sponsor->firstname]), $data);

            return $this->successResponse(trans('messages.successful_refused_group_deleting'));
        }

    }

    public function updateGroup(Request $request)
    {
        $this->validate($request, [
            'code_groupe' => 'required',
            'code_sponsor1' => 'required',
            'code_sponsor2' => 'required',
            'code_sponsor3' => 'required',
            'password' => 'required',
            'limite_credit' => 'required|numeric|min:0|not_in:0',
        ]);
        $group = UsersGroup::where('code_groupe', $request->code_groupe)->firstOrFail();
        $user = User::findOrFail($group->id_createur);
        if (!$this->checkPassword($request->password, $user->encrypted_password, $user->salt))
            return $this->errorResponse(trans('messages.incorrect_user_password'));

        //Verifier s'il n'est pas sponsor
        if (in_array($user->user_code, [$request->code_sponsor1, $request->code_sponsor2, $request->code_sponsor3]))
            return $this->errorResponse(trans('errors.cannot_be_sponsor'));

        //Verifier l'unicite de chacun des trois sponsors
        if ($this->array_has_dupes([$request->code_sponsor1, $request->code_sponsor2, $request->code_sponsor3]))
            return $this->errorResponse(trans('errors.sponsors_must_be_unique'));

        $sponsor1 = User::where('user_code', $request->code_sponsor1)->firstOrFail();
        $sponsor2 = User::where('user_code', $request->code_sponsor2)->firstOrFail();
        $sponsor3 = User::where('user_code', $request->code_sponsor3)->firstOrFail();

        $init_country = $user->network->country->id;
        $result = ConfigWallet::join('networks', 'networks.id', '=', 'configWallet.id_network')
            ->where('networks.country_id', $init_country)->where('configWallet.type', 'ilink')
            ->select('configWallet.id')->first();
        if ($result) {
            $config = ConfigWallet::findOrFail($result->id);
        } else {
            return $this->errorResponse(trans('errors.no_ilink_network'));
        }

        if ($request->limite_credit > $config->limite_credit_max)
            return $this->errorResponse(trans('errors.credit_limit_is_greater_than_max'));
        if ($request->limite_credit < $config->limite_credit_min)
            return $this->errorResponse(trans('errors.credit_limit_is_less_than_min'));

        if ($sponsor1->id != $group->id_sponsor1) {
            $prevSponsor1 = $group->sponsor1;
            //Check sponsor 1
            $resp1 = $this->checkSponsorIdentification($request->code_sponsor1, 1, $init_country);
            if ($resp1 instanceof Identification)
                $group->id_sponsor1 = $resp1->id_user;
            else
                return $resp1;

            --$group->nombre_validation;
            $prevSponsor1->group_id = null;
        }
        if ($sponsor2->id != $group->id_sponsor2) {
            $prevSponsor2 = $group->sponsor2;
            //Check sponsor 2
            $resp2 = $this->checkSponsorIdentification($request->code_sponsor2, 2, $init_country);
            if ($resp2 instanceof Identification)
                $group->id_sponsor2 = $resp2->id_user;
            else
                return $resp2;

            --$group->nombre_validation;
            $prevSponsor2->group_id = null;
        }
        if ($sponsor3->id != $group->id_sponsor3) {
            $prevSponsor3 = $group->sponsor3;
            //Check sponsor 3
            $resp3 = $this->checkSponsorIdentification($request->code_sponsor3, 3, $init_country);
            if ($resp3 instanceof Identification)
                $group->id_sponsor3 = $resp3->id_user;
            else
                return $resp3;

            --$group->nombre_validation;
            $prevSponsor3->group_id = null;
        }

        $group->fill($request->all());
        $group->actif = false;
        $group->date_activation = null;
        if (isset($prevSponsor1)) {
            $prevSponsor1->save();
            $this->sendNotificationToSponsor($group->id, $group->id_sponsor1, $request->code_sponsor1, $user);
        }
        if (isset($prevSponsor2)) {
            $prevSponsor2->save();
            $this->sendNotificationToSponsor($group->id, $group->id_sponsor2, $request->code_sponsor2, $user);
        }
        if (isset($prevSponsor3)) {
            $prevSponsor3->save();
            $this->sendNotificationToSponsor($group->id, $group->id_sponsor3, $request->code_sponsor3, $user);
        }
        $group->save();

        return $this->successResponse(trans('messages.successful_user_group_modificated'));
    }


    public function sendNotificationToSponsor($id_group, $id_sponsor, $sponsor_code, User $sender, $type = 'creation')
    {
        $demande = new UsersGroupsDemandesValidation();
        $demande->id_group = $id_group;
        $demande->id_sponsor = $id_sponsor;
        $demande->date_creation = new \DateTime();
        $demande->statut = false;
        $demande->type = $type;
        $demande->save();

        $data = new \stdClass();
        $data->screen = $type == 'creation' ? "demandeValidationGroupe" : "demandeSuppressionGroupe";
        $data->data = new \stdClass();
        $data->data->id = $demande->id;

        if ($type == 'creation')
            $this->sendPushNotificationToUser($sponsor_code,
                trans('notifications.group_validation_request', ['name' => $sender->lastname . ' ' . $sender->firstname]), $data);
        else
            $this->sendPushNotificationToUser($sponsor_code,
                trans('notifications.group_deleting_request', ['name' => $sender->lastname . ' ' . $sender->firstname]), $data);
    }

    public function getGroupDemand($id_demand)
    {

        $demand = collect(DB::select('SELECT * FROM users_groups_demandes_validations ugd
                    INNER JOIN infos_users_groups ug ON ug.id = ugd.id_group WHERE ugd.id = :id;', ['id' => $id_demand]))->first();
        if ($demand)
            return $this->successResponse($demand);
        else
            return $this->errorResponse(trans('errors.model_not_found', ['model' => 'groupValidationDemand']), Response::HTTP_BAD_REQUEST);
    }

    public function getAllGroupDemand($id_user)
    {

        $demands = DB::select('SELECT * FROM users_groups_demandes_validations ugd
                    INNER JOIN infos_users_groups ug ON ug.id = ugd.id_group WHERE ugd.id_sponsor = :id;', ['id' => $id_user]);

        return $this->successResponse($demands);
    }

    public function joinGroup(Request $request)
    {
        $this->validate($request, [
            'code_groupe' => 'required',
            'code_sponsor' => 'required',
            'id_user' => 'required|integer|min:0|not_in:0'
        ]);

        $group = UsersGroup::where('code_groupe', $request->code_groupe)->firstOrFail();
        if (!$group->actif)
            return $this->errorResponse(trans('errors.group_not_active'));

        $sponsor = User::where('user_code', $request->code_sponsor)->firstOrFail();
        if (!in_array($sponsor->id, [$group->id_sponsor1, $group->id_sponsor2, $group->id_sponsor3]))
            return $this->errorResponse(trans('errors.not_group_sponsor'));

        $user = User::findOrFail($request->id_user);
        if (isset($user->group_id))
            return $this->errorResponse(trans('errors.belongs_to_group'));

        //Check user identification
        $country_sponsor = $sponsor->network->country->id;
        $country_user = $user->network->country->id;
        if ($country_user != $country_sponsor)
            return $this->errorResponse(trans('errors.not_registered_in_same_country'));

        $this->checkMyIdentification($request->id_user);

        $user->group_id = $group->id;
        $user->save();
        ++$group->nombre_utilisateurs;
        $group->save();
        // Notifier les determinants
        return $this->successResponse(trans('messages.successful_group_adhesion'));

    }

    public function deleteGroup(Request $request)
    {
        $this->validate($request, [
            'code_groupe' => 'required',
            'id_user' => 'required|integer|min:0|not_in:0'
        ]);

        $group = UsersGroup::where('code_groupe', $request->code_groupe)->firstOrFail();
        if ($group->id_createur != $request->id_user)
            return $this->errorResponse(trans('errors.not_group_creator'));

        $this->sendNotificationToSponsor($group->id, $group->id_sponsor1, $group->sponsor1->user_code, $group->createur, 'suppression');
        $this->sendNotificationToSponsor($group->id, $group->id_sponsor2, $group->sponsor2->user_code, $group->createur, 'suppression');
        $this->sendNotificationToSponsor($group->id, $group->id_sponsor3, $group->sponsor3->user_code, $group->createur, 'suppression');

        return $this->successResponse(trans('messages.successful_user_group_deleted'));

    }

    private function validateDeletingGroupDemand(Request $request)
    {
        $this->validate($request, [
            'id_demande' => 'required|integer|min:0|not_in:0',
            'id_user' => 'required|integer|min:0|not_in:0'
        ]);

        $demande = UsersGroupsDemandesValidation::findOrFail($request->id_demande);
        if ($demande->statut != 0)
            return $this->errorResponse(trans('errors.treated_group_demand'));

        if ($demande->id_sponsor != $request->id_user)
            return $this->errorResponse(trans('errors.not_group_sponsor'));

        $sponsor = User::findOrFail($request->id_user);
        $group = UsersGroup::findOrFail($demande->id_group);
        if (!in_array($demande->id_sponsor, [$group->id_sponsor1, $group->id_sponsor2, $group->id_sponsor3]))
            return $this->errorResponse(trans('errors.not_group_sponsor'));


        ++$group->nombre_suppression;
        if ($group->nombre_suppression == 3) {
            $group->actif = false;
            $group->nombre_validation = 0;
            $group->date_activation = null;
            $users = User::where('group_id', $group->id)->get();
            foreach ($users as $user) {
                $user->group_id = null;
                $user->date_adhesion = null;
                $user->save();
            }
            $group->deleted = true;
        }
        $group->save();
        $demande->statut = true;
        $demande->date_validation = new \DateTime();
        $demande->save();
        // Notififier le createur
        $data = new \stdClass();
        $data->screen = "notificationview";
        $data->data = new \stdClass();;
        $data->data->id = $request->id_demande;
        $this->sendPushNotificationToUser($group->createur->user_code,
            trans('notifications.accepted_group_deleting_request', ['name' => $sponsor->lastname . ' ' . $sponsor->firstname]), $data);

        return $this->successResponse(trans_choice('messages.successful_group_deleting', 3 - $group->nombre_validation, ['count' => (3 - $group->nombre_validation)]));

    }

    private function checkSponsorIdentification($code_sponsor, $id, $init_country)
    {
        $sponsor = User::where('user_code', $code_sponsor)->first();
        if ($sponsor) {
            //Verifier s'il appartient a un groupe
            if (isset($sponsor->group_id))
                return $this->errorResponse(trans('errors.sponsor_belongs_to_group', ['id' => $id]));
            $sponsor_country = $sponsor->network->country->id;
            if ($init_country != $sponsor_country)
                return $this->errorResponse(trans('errors.sponsor_not_registered_in_same_country', ['id' => $id]));

            return $this->checkUserIdentification($sponsor->id, $id);
        } else {
            return $this->errorResponse(trans('errors.sponsor_not_found', ['id' => $id]));
        }
    }

    private function checkUserIdentification($id_user, $id)
    {
        $identification = Identification::where('id_user', $id_user)->first();
        if (isset($identification)) {
            if ($identification->status == 0)
                return $this->errorResponse(trans('errors.validation_sponsor_identification_required', ['id' => $id]));
            else
                return $identification;
        } else {
            return $this->errorResponse(trans('errors.sponsor_identification_required', ['id' => $id]));
        }
    }

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

    private function generateGroupCode($length = 8)
    {
        $characters = '23456789ABCDEFGHJKLMNOPQRSTUVWXYZ';
        $charactersLength = strlen($characters);
        $randomString = '';
        for ($i = 0; $i < $length; $i++) {
            $randomString .= $characters[rand(0, $charactersLength - 1)];
        }
        return $randomString;
    }

    private function checkMyIdentification($id)
    {
        $identification = Identification::where('id_user', $id)->first();
        if (isset($identification)) {
            if ($identification->status == 0)
                return $this->errorResponse(trans('errors.validation_identification_required'));
        } else {
            return $this->errorResponse(trans('errors.identification_required'));
        }
    }

    // Gestion du nano credit

    public function askNanoCredit(Request $request)
    {

        $this->validate($request, [
            'type_caution' => 'required|in:groupe,individuel',
            'duree_mois' => 'required|integer|min:0|not_in:0',
            'id_user' => 'required|integer|min:0|not_in:0',
            'password' => 'required',
            'montant' => 'required|numeric|min:0|not_in:0',
        ]);

        $user = User::findOrFail($request->id_user);
        if (!$this->checkPassword($request->password, $user->encrypted_password, $user->salt))
            return $this->errorResponse(trans('messages.incorrect_user_password'));

        $this->checkMyIdentification($request->id_user);

        $init_country = $user->network->country->id;
        $result = ConfigWallet::join('networks', 'networks.id', '=', 'configWallet.id_network')
            ->where('networks.country_id', $init_country)->where('configWallet.type', 'ilink')
            ->select('configWallet.id')->first();
        if ($result) {
            $config = ConfigWallet::findOrFail($result->id);
        } else {
            return $this->errorResponse(trans('errors.no_ilink_network'));
        }

        $taxes = array_values(array_filter($config->taxes->all(), function ($tax) {
            return $tax->categorie == 'nano_credit';
        }));

        $paliers = array_values($config->paliers_config_nano_credits->all());

        $demande_credit = new UsersDemandesCredit();
        $demande_credit->fill($request->all());

        if ($request->type_caution == 'groupe') {

            $group = UsersGroup::find($user->group_id);
            if (!$group)
                return $this->errorResponse(trans('errors.not_belongs_to_any_group'));

            if (!$group->actif)
                return $this->errorResponse(trans('errors.your_group_not_active'));

            if ($group->nombre_utilisateurs < 10)
                return $this->errorResponse(trans('errors.your_group_not_valid'));

            if ($request->montant < $group->limite_credit)
                return $this->errorResponse(trans('errors.nano_credit_amount_must_be_less_than_group_limit'));


            $walletUser = WalletsUser::where('idUser', $request->id_user)->firstOrFail();

            $demande_credit->frais = $this->calculateFees($paliers, $request->montant, $request->duree_mois);
            $demande_credit->taxe = $this->calculateTax($taxes, $demande_credit->frais);
            $demande_credit->date_demande = new \DateTime();
            $demande_credit->date_rembourssement = $demande_credit->date_demande->modify('+' . $request->duree_mois . ' month');
            $demande_credit->etat = 'VALIDE';
            $demande_credit->id_demande = $this->getNanoCreditDemandID();

            $montant_total = $demande_credit->montant + $demande_credit->frais + $demande_credit->taxe;

            $user->balance_credit += $montant_total;
            $walletUser->balance += $demande_credit->montant;
            $user->save();
            $walletUser->save();
            $demande_credit->save();

            $message = trans('messages.successful_user_group_nano_credit_demand',
                ['id_demand' => $demande_credit->id_demande, 'amount' => $this->toMoney($montant_total, $init_country),
                    'net' => $this->toMoney($demande_credit->montant, $init_country), 'fees' => $this->toMoney($demande_credit->frais + $demande_credit->taxe, $init_country),
                    'date' => $demande_credit->date_rembourssement]);
            $this->sendMail($user->email, trans('messages.successful_nano_credit_demand'), $message);
            return $this->successResponse($message . trans('messages.sent_by_mail'));

        }

        if ($request->type_caution == 'individuel') {

            $demande_credit->frais = $this->calculateFees($paliers, $request->montant, $request->duree_mois);
            $demande_credit->taxe = $this->calculateTax($taxes, $demande_credit->frais);
            $demande_credit->etat = 'EN_ATTENTE_DE_VALIDATION';

            $montant_total = $demande_credit->montant + $demande_credit->frais + $demande_credit->taxe;

            $demande_credit->id_demande = $this->getNanoCreditDemandID();
            $demande_credit->save();

            $message = trans('messages.successful_user_individual_nano_credit_demand',
                ['id_demand' => $demande_credit->id_demande, 'amount' => $this->toMoney($montant_total, $init_country),
                    'net' => $this->toMoney($demande_credit->montant, $init_country),
                    'fees' => $this->toMoney($demande_credit->frais + $demande_credit->taxe, $init_country),]);
            $this->sendMail($user->email, trans('messages.successful_nano_credit_demand'), $message);
            return $this->successResponse($message . trans('messages.sent_by_mail'));
        }

    }

    // Calculer les frais
    private function calculateFees(array $paliers, $montant, $duree)
    {
        $size = sizeof($paliers);
        if ($size > 0) {
//           $mois = array_map(function ($palier) {
//               return $palier->duree_mois;
//           },$paliers);

            $palier = null;
            foreach ($paliers as $p) {
                if ($p->duree_mois == $duree) {
                    $palier = $p;
                    break;
                }
            }

            if ($palier) {
                return $palier->taux * $montant / 100;
            }
        }
        return 0;
    }

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

}