672 lines
29 KiB
PHP
Executable File
672 lines
29 KiB
PHP
Executable File
<?php
|
|
|
|
namespace App\Http\Controllers;
|
|
|
|
use App\Models\ConfigWallet;
|
|
use App\Models\Identification;
|
|
use App\Models\User;
|
|
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 Illuminate\Http\Request;
|
|
use Illuminate\Http\Response;
|
|
use Illuminate\Support\Facades\DB;
|
|
|
|
class UserGroupController extends Controller
|
|
{
|
|
/**
|
|
* 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'));
|
|
|
|
$identfication = $this->checkMyIdentification($request->id_user);
|
|
if (!($identfication instanceof Identification))
|
|
return $identfication;
|
|
|
|
//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 || $request->limite_credit < $config->limite_credit_min)
|
|
return $this->errorResponse(trans('errors.group_credit_limit_must_be_between',
|
|
['min_limit' => $this->toMoney($config->limite_credit_min, $init_country), 'max_limit' => $this->toMoney($config->limite_credit_max, $init_country)]));
|
|
|
|
$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 = $this->getCurrentTime($init_country);
|
|
$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 = $group->date_creation;
|
|
$user->save();
|
|
|
|
$this->sendNotificationToSponsor($group->id, $group->id_sponsor1, $request->code_sponsor1, $user, $init_country);
|
|
$this->sendNotificationToSponsor($group->id, $group->id_sponsor2, $request->code_sponsor2, $user, $init_country);
|
|
$this->sendNotificationToSponsor($group->id, $group->id_sponsor3, $request->code_sponsor3, $user, $init_country);
|
|
|
|
return $this->successResponse(trans('messages.successful_user_group_created'));
|
|
|
|
}
|
|
|
|
public function validateGroupDemand(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->type != 'nano_credit')
|
|
if ($demande->id_sponsor != $request->id_user)
|
|
return $this->errorResponse(trans('errors.not_group_sponsor'));
|
|
|
|
if ($demande->type == 'creation')
|
|
return $this->validateGroupCreationDemand($request, $demande);
|
|
if ($demande->type == 'suppression')
|
|
return $this->validateDeletingGroupDemand($request, $demande);
|
|
if ($demande->type == 'adhesion')
|
|
return $this->validateMembershipGroupDemand($request, $demande);
|
|
if ($demande->type == 'nano_credit')
|
|
return $this->validateNanoCreditGroupDemand($request, $demande);
|
|
|
|
}
|
|
|
|
|
|
private function validateGroupCreationDemand(Request $request, UsersGroupsDemandesValidation $demande)
|
|
{
|
|
|
|
$sponsor = User::findOrFail($request->id_user);
|
|
$group = UsersGroup::findOrFail($demande->id_group);
|
|
|
|
if ($group->actif)
|
|
return $this->errorResponse(trans('errors.group_already_active'));
|
|
|
|
$datetime = $this->getCurrentTimeByCountryCode($sponsor->network->country->code_country);
|
|
|
|
++$group->nombre_validation;
|
|
++$group->nombre_utilisateurs;
|
|
if ($group->nombre_validation == 3) {
|
|
$group->actif = true;
|
|
$group->date_activation = $datetime;
|
|
}
|
|
|
|
$sponsor->group_id = $group->id;
|
|
$sponsor->date_adhesion = $datetime;
|
|
$sponsor->save();
|
|
$group->save();
|
|
$demande->statut = true;
|
|
$demande->date_validation = $sponsor->date_adhesion;
|
|
$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, $demande->date_validation);
|
|
|
|
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',
|
|
]);
|
|
$demande = UsersGroupsDemandesValidation::findOrFail($request->id_demande);
|
|
if ($demande->statut != 0)
|
|
return $this->errorResponse(trans('errors.treated_group_demand'));
|
|
|
|
if ($demande->type != 'nano_credit')
|
|
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 = $this->getCurrentTimeByCountryCode($sponsor->network->country->code_country);
|
|
$demande->save();
|
|
// Notififier le createur
|
|
$data = new \stdClass();
|
|
$data->screen = "notificationview";
|
|
$data->data = new \stdClass();
|
|
$data->data->id = $request->id_demande;
|
|
|
|
if ($demande->type == 'creation') {
|
|
$this->sendPushNotificationToUser($group->createur->user_code,
|
|
trans('notifications.refused_group_validation_request', ['name' => $sponsor->lastname . ' ' . $sponsor->firstname]), $data, $demande->date_validation);
|
|
|
|
return $this->successResponse(trans('messages.successful_refused_group_validation'));
|
|
}
|
|
|
|
if ($demande->type == 'suppression') {
|
|
$this->sendPushNotificationToUser($group->createur->user_code,
|
|
trans('notifications.refused_group_deleting_request', ['name' => $sponsor->lastname . ' ' . $sponsor->firstname]), $data, $demande->date_validation);
|
|
|
|
return $this->successResponse(trans('messages.successful_refused_group_deleting'));
|
|
}
|
|
|
|
if ($demande->type == 'adhesion') {
|
|
$user = User::findOrFail($demande->id_user);
|
|
$this->sendPushNotificationToUser($user->user_code,
|
|
trans('notifications.successful_canceled_group_membership_request', ['name' => $sponsor->lastname . ' ' . $sponsor->firstname]), $data, $demande->date_validation);
|
|
|
|
return $this->successResponse(trans('messages.successful_canceled_group_membership_request'));
|
|
}
|
|
|
|
if ($demande->type == 'nano_credit') {
|
|
$user = User::findOrFail($demande->id_user);
|
|
$this->sendPushNotificationToUser($user->user_code, trans('notifications.refused_group_nano_credit_request'), $data, $demande->date_validation);
|
|
|
|
return $this->successResponse(trans('messages.successful_canceled_nano_credit_request'));
|
|
}
|
|
|
|
return $this->errorResponse(trans('errors.unexpected_error'));
|
|
|
|
}
|
|
|
|
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;
|
|
$prevSponsor1->date_adhesion = 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;
|
|
$prevSponsor2->date_adhesion = 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;
|
|
$prevSponsor3->date_adhesion = 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, $init_country);
|
|
}
|
|
if (isset($prevSponsor2)) {
|
|
$prevSponsor2->save();
|
|
$this->sendNotificationToSponsor($group->id, $group->id_sponsor2, $request->code_sponsor2, $user, $init_country);
|
|
}
|
|
if (isset($prevSponsor3)) {
|
|
$prevSponsor3->save();
|
|
$this->sendNotificationToSponsor($group->id, $group->id_sponsor3, $request->code_sponsor3, $user, $init_country);
|
|
}
|
|
$group->save();
|
|
|
|
return $this->successResponse(trans('messages.successful_user_group_modificated'));
|
|
}
|
|
|
|
|
|
private function sendNotificationToSponsor($id_group, $id_sponsor, $sponsor_code, User $sender, $init_country, $type = 'creation')
|
|
{
|
|
$demande = new UsersGroupsDemandesValidation();
|
|
$demande->id_group = $id_group;
|
|
$demande->id_sponsor = $id_sponsor;
|
|
$demande->date_creation = $this->getCurrentTime($init_country);
|
|
$demande->statut = false;
|
|
$demande->type = $type;
|
|
|
|
|
|
$data = new \stdClass();
|
|
|
|
if ($type == 'creation') {
|
|
$data->screen = "demandeValidationGroupe";
|
|
$message_id = 'notifications.group_validation_request';
|
|
} else if ($type == 'suppression') {
|
|
$data->screen = "demandeValidationGroupe"; //"demandeSuppressionGroupe";
|
|
$message_id = 'notifications.group_deleting_request';
|
|
} else if ($type == 'adhesion') {
|
|
$demande->id_user = $sender->id;
|
|
$data->screen = "demandeValidationGroupe"; //"demandJoinGroup";
|
|
$message_id = 'notifications.group_membership_request';
|
|
} else {
|
|
$data->screen = "notificationview";
|
|
$message_id = 'notifications.group_deleting_request';
|
|
}
|
|
|
|
$demande->save();
|
|
$data->data = new \stdClass();
|
|
$data->data->id = $demande->id;
|
|
|
|
$this->sendPushNotificationToUser($sponsor_code,
|
|
trans($message_id, ['name' => $sender->lastname . ' ' . $sender->firstname]), $data, $demande->date_creation);
|
|
|
|
}
|
|
|
|
public function getGroupDemand($id_demand)
|
|
{
|
|
|
|
$demand = collect(DB::select('SELECT ugd.* , ugd.date_creation as date_creation_demande , ug.code_groupe , ug.nom , ug.limite_credit , ug.nombre_validation, ug.actif, ug.nombre_utilisateurs,
|
|
ug.date_creation as date_creation_groupe , ug.createur , ug.sponsor1 , ug.sponsor2 , ug.sponsor3, ug.country, ug.currency_code 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) {
|
|
unset($demand->date_creation);
|
|
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 ugd.* , ugd.date_creation as date_creation_demande , ug.code_groupe , ug.nom , ug.limite_credit , ug.nombre_validation, ug.actif, ug.nombre_utilisateurs,
|
|
ug.date_creation as date_creation_groupe , ug.createur , ug.sponsor1 , ug.sponsor2 , ug.sponsor3, ug.country, ug.currency_code 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]);
|
|
|
|
foreach ($demands as $demand)
|
|
unset($demand->date_creation);
|
|
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.sponsor_code_not_match'));
|
|
|
|
$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'));
|
|
|
|
$identfication = $this->checkMyIdentification($request->id_user);
|
|
if (!($identfication instanceof Identification))
|
|
return $identfication;
|
|
|
|
// Notifier le sponsor
|
|
$this->sendNotificationToSponsor($group->id, $sponsor->id, $sponsor->user_code, $user, $country_user, 'adhesion');
|
|
return $this->successResponse(trans('messages.successful_group_membership_request'));
|
|
|
|
}
|
|
|
|
private function validateMembershipGroupDemand(Request $request, UsersGroupsDemandesValidation $demande)
|
|
{
|
|
|
|
$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'));
|
|
|
|
$user = User::findOrFail($demande->id_user);
|
|
if ($user->group_id)
|
|
return $this->errorResponse(trans('errors.user_already_member_of_group'));
|
|
$user->group_id = $group->id;
|
|
$user->date_adhesion = $this->getCurrentTimeByCountryCode($sponsor->network->country->code_country);
|
|
$user->save();
|
|
++$group->nombre_utilisateurs;
|
|
$group->save();
|
|
|
|
$demande->statut = true;
|
|
$demande->date_validation = $user->date_adhesion;
|
|
$demande->save();
|
|
// Notififier l'utilisateur
|
|
$data = new \stdClass();
|
|
$data->screen = "notificationview";
|
|
$data->data = new \stdClass();
|
|
$data->data->id = $request->id_demande;
|
|
$this->sendPushNotificationToUser($user->user_code,
|
|
trans('notifications.accepted_group_membership_request', ['name' => $sponsor->lastname . ' ' . $sponsor->firstname]), $data, $demande->date_validation);
|
|
|
|
return $this->successResponse(trans('messages.successful_accepted_group_membership_request'));
|
|
|
|
}
|
|
|
|
public function deleteGroup(Request $request)
|
|
{
|
|
$this->validate($request, [
|
|
'code_groupe' => 'required',
|
|
'id_user' => 'required|integer|min:0|not_in:0'
|
|
]);
|
|
|
|
$user = User::findOrFail($request->id_user);
|
|
$country_user = $user->network->country->id;
|
|
$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, $country_user, 'suppression');
|
|
$this->sendNotificationToSponsor($group->id, $group->id_sponsor2, $group->sponsor2->user_code, $group->createur, $country_user, 'suppression');
|
|
$this->sendNotificationToSponsor($group->id, $group->id_sponsor3, $group->sponsor3->user_code, $group->createur, $country_user, 'suppression');
|
|
|
|
return $this->successResponse(trans('messages.successful_user_group_deleted'));
|
|
|
|
}
|
|
|
|
private function validateDeletingGroupDemand(Request $request, UsersGroupsDemandesValidation $demande)
|
|
{
|
|
|
|
$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 = $this->getCurrentTimeByCountryCode($sponsor->network->country->code_country);
|
|
$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, $demande->date_validation);
|
|
|
|
return $this->successResponse(trans_choice('messages.successful_group_deleting', 3 - $group->nombre_validation, ['count' => (3 - $group->nombre_validation)]));
|
|
|
|
}
|
|
|
|
public function myGroup($code_user)
|
|
{
|
|
|
|
$groupe = collect(DB::select('SELECT ug.code_groupe , ug.nom , ug.limite_credit , ug.nombre_validation, ug.actif, ug.nombre_utilisateurs,
|
|
ug.date_creation , ug.createur , ug.sponsor1 , ug.sponsor2 , ug.sponsor3, ug.country, ug.currency_code, ug.id_createur , code_sponsor1 as codeSponsor1 , code_sponsor2 as codeSponsor2,
|
|
code_sponsor3 as codeSponsor3 FROM infos_users_groups ug
|
|
INNER JOIN users u ON ug.id = u.group_id WHERE u.user_code = :code', ['code' => $code_user]))->first();
|
|
|
|
if ($groupe)
|
|
return $this->successResponse($groupe);
|
|
else
|
|
return $this->errorResponse(trans('errors.not_belongs_to_any_group'));
|
|
|
|
}
|
|
|
|
public function myGroupLimits($code_user)
|
|
{
|
|
$user = User::where('user_code', $code_user)->firstOrFail();
|
|
|
|
$country = $user->network->country;
|
|
$init_country = $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);
|
|
$rep = new \stdClass();
|
|
$rep->limite_credit_min = $config->limite_credit_min;
|
|
$rep->limite_credit_max = $config->limite_credit_max;
|
|
$rep->currency_code = $country->currency->code;
|
|
return $this->successResponse($rep);
|
|
} else {
|
|
return $this->errorResponse(trans('errors.no_ilink_network'));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
private function validateNanoCreditGroupDemand(Request $request, UsersGroupsDemandesValidation $demande)
|
|
{
|
|
|
|
$walletHyper = WalletAgent::where('agent_id', $demande->id_agent)->firstOrFail();
|
|
$demande_credit = UsersDemandesCredit::where('id_demande', $demande->id_demande)->firstOrFail();
|
|
|
|
if ($demande_credit->montant > $walletHyper->balance_princ)
|
|
return $this->errorResponse(trans('errors.insufficient_balance'));
|
|
|
|
$currency_code = $walletHyper->currency_code;
|
|
$walletHyper = Wallet::findOrFail($walletHyper->wallet_id);
|
|
|
|
|
|
$user = User::findOrFail($demande->id_user);
|
|
$walletUser = WalletsUser::where('idUser', $request->id_user)->firstOrFail();
|
|
|
|
$montant_total = $demande_credit->montant + $demande_credit->frais + $demande_credit->taxe;
|
|
$datetime = $this->getCurrentTimeByCountryCode($user->network->country->code_country);
|
|
|
|
$demande_credit->date_validation = $datetime;
|
|
$demande_credit->date_remboursement_prevu = $demande_credit->date_validation->modify('+' . $demande_credit->duree_mois . ' month');
|
|
$demande_credit->etat = 'VALIDE';
|
|
|
|
$user->balance_credit += $montant_total;
|
|
$walletUser->balance += $demande_credit->montant;
|
|
$walletHyper->balance_princ -= $demande_credit->montant;
|
|
|
|
$demande->statut = true;
|
|
$demande->date_validation = $datetime;
|
|
$user->save();
|
|
$walletUser->save();
|
|
$walletHyper->save();
|
|
$demande_credit->save();
|
|
$demande->save();
|
|
// Notififier l'utilisateur
|
|
$data = new \stdClass();
|
|
$data->screen = "notificationview";
|
|
$data->data = new \stdClass();
|
|
$data->data->id = $request->id_demande;
|
|
$this->sendPushNotificationToUser($user->user_code, trans('notifications.accepted_group_nano_credit_request'), $data, $demande->date_validation);
|
|
|
|
$message = trans('messages.successful_user_group_nano_credit_demand',
|
|
['id_demand' => $demande_credit->id_demande, 'amount' => $this->toMoneyWithCurrencyCode($montant_total, $currency_code),
|
|
'net' => $this->toMoneyWithCurrencyCode($demande_credit->montant, $currency_code), 'fees' => $this->toMoneyWithCurrencyCode($demande_credit->frais + $demande_credit->taxe, $currency_code),
|
|
'date' => $demande_credit->date_remboursement_prevu]);
|
|
$this->sendMail($user->email, trans('messages.successful_nano_credit_demand'), $message);
|
|
|
|
return $this->successResponse(trans('messages.successful_accepted_nano_credit_request'));
|
|
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
}
|