walletservice/app/Http/Controllers/NanoCreditController.php

<?php

namespace App\Http\Controllers;

use App\Models\AgentPlus;
use App\Models\CodeGenerer;
use App\Models\ConfigWallet;
use App\Models\Identification;
use App\Models\InfosUsersGroup;
use App\Models\NetworksAgent;
use App\Models\UsersDemandesCredit;
use App\Models\UsersGroup;
use App\Models\UsersGroupsDemandesValidation;
use App\Models\Wallet;
use App\Models\WalletAgent;
use App\Models\WalletsUser;
use App\Traits\ApiResponser;
use App\Traits\Helper;
use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Support\Facades\DB;

class NanoCreditController extends Controller
{
    use ApiResponser;
    use Helper;

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

    // 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'));

        $identfication = $this->checkMyIdentification($request->id_user);
        if (!($identfication instanceof Identification))
            return $identfication;

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

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

        $paliers = array_values(array_filter($config->paliers_config_nano_credits->all(), function ($taux) {
            return $taux->type == 'nano_credit';
        }));

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

        // Derniere demande de nano credit
        $last_demand = UsersDemandesCredit::where('id_user', $request->id_user)->where('etat', 'VALIDE')->first();
        if ($last_demand)
            return $this->errorResponse(trans('errors.last_nano_credit_not_refunded'));

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

            //Verifier la capacité d'emprunt
            $CE = $this->capaciteEmprunt($group->id);
            if ($CE < 0)
                return $this->errorResponse("Le groupe n'a pas le droit d'emprenunter");
            if ($request->montant > $CE)
                return $this->errorResponse("La capicite d'emprunt est dépassé");

            //Verifier si le solde principal de l'hyperviseur est superieur au montant
            $walletHyper = WalletAgent::where('category', 'hyper')->where('network_id', $config->id_network)->firstOrFail();

            $demande_credit->frais = $this->calculateFees($paliers, $request->montant, $request->duree_mois);
            $demande_credit->taxe = $this->calculateTax($taxes, $demande_credit->frais);
            $demande_credit->id_demande = $this->getNanoCreditDemandID();

            if ($request->montant > $walletHyper->balance_princ) {
                $demande_credit->etat = 'EN_ATTENTE_DE_VALIDATION';
                $demande_credit->save();

                $demande = new UsersGroupsDemandesValidation();
                $demande->id_group = $group->id;
                $demande->id_user = $user->id;
                $demande->id_demande = $demande_credit->id_demande;
                $demande->id_agent = $walletHyper->agent_id;
                $demande->date_creation = new \DateTime();
                $demande->statut = false;
                $demande->type = 'nano_credit';
                $demande->save();

                $data = new \stdClass();
                $data->screen = "notificationview";
                $data->data = new \stdClass();
                $data->data->id = $demande->id;

                $this->sendPushNotificationToAgent($walletHyper->codeMembre,
                    trans('notifications.group_nano_credit_request', ['name' => $group->nom]), $data);
                return $this->successResponse(trans('messages.successful_nano_credit_sent_to_hypervisor'));

            } else {
                $walletHyper = Wallet::findOrFail($walletHyper->wallet_id);
                $walletUser = WalletsUser::where('idUser', $request->id_user)->firstOrFail();

                $demande_credit->date_demande = new \DateTime();
                $demande_credit->date_remboursement_prevu = $demande_credit->date_demande->modify('+' . $request->duree_mois . ' month');
                $demande_credit->etat = 'VALIDE';

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

                $user->balance_credit += $montant_total;
                $walletUser->balance += $demande_credit->montant;
                $walletHyper->balance_princ -= $demande_credit->montant;
                $user->save();
                $walletUser->save();
                $walletHyper->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_remboursement_prevu]);
                $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'));
        }

    }

    public function getNanoCreditsDemands($id_user)
    {
        $demandes = DB::select('SELECT * FROM infos_users_demandes_credits WHERE id_user = :id;', ['id' => $id_user]);
        return $this->successResponse($demandes);
    }

    public function cautionnerCredit(Request $request)
    {
        $this->validate($request, [
            'id_demande' => 'required',
            'id_wallet_agent' => 'required|integer|min:0|not_in:0',
            'retrait_cash' => 'required|boolean',
            'password' => 'required',
        ]);

        $walletAgent = Wallet::findOrFail($request->get('id_wallet_agent'));
        $network_agent = NetworksAgent::findOrFail($walletAgent->id_networkAgent);
        $agent_country = $network_agent->network->country->id;

        $agent = AgentPlus::findOrFail($network_agent->agent_id);
        if (!$this->checkPassword($request->password, $agent->encrypted_password, $agent->salt))
            return $this->errorResponse(trans('messages.incorrect_user_password'));

        $demande_credit = UsersDemandesCredit::where('id_demande', $request->id_demande)->first();
        $demande_credit->retrait_cash = $request->retrait_cash;
        if (!$demande_credit)
            return $this->errorResponse(trans('errors.nano_credit_not_found'));

        if ($demande_credit->type_caution != 'individuel')
            return $this->errorResponse(trans('errors.nano_credit_not_individual'));


        if ($demande_credit->etat == 'VALIDE')
            return $this->errorResponse(trans('messages.treated_demand'));

        $user = User::findOrFail($demande_credit->id_user);
        $user_country = $user->network->country->id;

        if ($user_country != $agent_country)
            return $this->errorResponse('errors.operation_cannot_performed_in_country');

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

        if ($montant_total > $walletAgent->balance_princ)
            return $this->errorResponse(trans('errors.insufficient_balance'));


        $demande_credit->date_demande = new \DateTime();
        $demande_credit->date_remboursement_prevu = $demande_credit->date_demande->modify('+' . $demande_credit->duree_mois . ' month');
        $demande_credit->etat = 'VALIDE';
        $demande_credit->id_wallet_agent = $walletAgent->id;
        $user->balance_credit += $montant_total;

        $walletAgent->balance_princ -= $montant_total;

        //Crediter le wallet de client s'il ne retire pas en cash
        if (!$request->retrait_cash) {
            $walletUser = WalletsUser::where('idUser', $demande_credit->id_user)->firstOrFail();
            $walletUser->balance += $demande_credit->montant;
            $walletUser->save();
        }

        $walletAgent->save();
        $user->save();
        $demande_credit->save();

        $user_message = trans('messages.successful_guarantee_user_individual_nano_credit_demand',
            ['id_demand' => $demande_credit->id_demande, 'amount' => $this->toMoney($montant_total, $agent_country),
                'net' => $this->toMoney($demande_credit->montant, $agent_country), 'fees' => $this->toMoney($demande_credit->frais + $demande_credit->taxe, $agent_country),
                'date' => $demande_credit->date_remboursement_prevu, 'agent_name' => $agent->lastname . ' ' . $agent->firstname, 'code_agent' => $agent->code_membre]);

        $agent_message = trans('messages.successful_guarantee_agent_individual_nano_credit_demand',
            ['id_demand' => $demande_credit->id_demande, 'amount' => $this->toMoney($montant_total, $agent_country),
                'net' => $this->toMoney($demande_credit->montant, $agent_country), 'fees' => $this->toMoney($demande_credit->frais + $demande_credit->taxe, $agent_country),
                'date' => $demande_credit->date_remboursement_prevu, 'user_name' => $user->lastname . ' ' . $user->firstname, 'code_user' => $user->user_code]);

        $this->sendMail($user->email, trans('messages.successful_guarantee_nano_credit_demand'), $user_message);
        $this->sendMail($agent->email, trans('messages.successful_guarantee_nano_credit_demand'), $agent_message);
        return $this->successResponse($agent_message . trans('messages.sent_by_mail'));
    }

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

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

        $walletUser = WalletsUser::where('idUser', $request->id_user)->firstOrFail();
        $demande_credit = UsersDemandesCredit::where('id_demande', $request->id_demande)->first();
        if (!$demande_credit)
            return $this->errorResponse(trans('errors.nano_credit_not_found'));

        if ($demande_credit->etat == 'REMBOURSE')
            return $this->errorResponse(trans('errors.nano_credit_already_refunded'));

        $init_country = $user->network->country->id;
        $montant_total = $demande_credit->montant + $demande_credit->frais + $demande_credit->taxe;

        if ($montant_total > $walletUser->balance)
            return $this->errorResponse(trans('errors.insufficient_balance'));

        $user->balance_credit -= $montant_total;
        $walletUser->balance -= $montant_total;
        $demande_credit->etat = 'REMBOURSE';

        if ($demande_credit->type_caution == 'individuel') {
            $walletAgent = Wallet::findOrFail($demande_credit->id_wallet_agent);

            $walletAgent->balance_princ += $montant_total;
            $walletAgent->save();
        }

        if ($demande_credit->type_caution == 'groupe') {
            // Recuperation des wallets hyperviseur et superviseur

            $walletHyper = WalletAgent::where('category', 'hyper')->where('network_id', $group->id_network)->firstOrFail();
            $walletHyper = Wallet::findOrFail($walletHyper->wallet_id);

            $walletHyper->balance_princ += $montant_total;
            $walletHyper->save();
        }

        $demande_credit->date_remboursement = new \DateTime();

        $walletUser->save();
        $user->save();
        $demande_credit->save();

        $message = trans('messages.successful_nano_credit_demand_refunded',
            ['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),
                'caution' => $demande_credit->type_caution == 'groupe' ? 'Groupe' : 'Individuel']);
        $this->sendMail($user->email, trans('messages.successful_nano_credit_refunded'), $message);
        return $this->successResponse($message . trans('messages.sent_by_mail'));
    }

    // Calculer la capacité d'emprunt

    private function capaciteEmprunt($id_group)
    {
        $users = User::where('group_id', $id_group)->get();
        $sommeCredits = 0;
        $sommeEpargnes = 0;
        foreach ($users as $user) {
            $sommeCredits += $user->balance_credit;
            $sommeEpargnes += $user->balance_epargne;
        }
        return $sommeEpargnes - $sommeCredits;
    }

    public function getDureeMois($id_user)
    {

        $user = User::findOrFail($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'));
        }

        if (!$config->has_nano_credit)
            return $this->errorResponse(trans('errors.nano_credit_not_available'));

        $paliers = array_values(array_filter($config->paliers_config_nano_credits->all(), function ($taux) {
            return $taux->type == 'nano_credit';
        }));

        $mois = array_map(function ($palier) {
            return ['value' => $palier->duree_mois];
        }, $paliers);

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

    // Calculer les frais
    private function calculateFees(array $paliers, $montant, $duree)
    {
        $size = sizeof($paliers);
        if ($size > 0) {
            $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;
    }

}