No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.

806 líneas
28KB

  1. <?php
  2. /**
  3. * Copyright distrib (2018)
  4. *
  5. * contact@opendistrib.net
  6. *
  7. * Ce logiciel est un programme informatique servant à aider les producteurs
  8. * à distribuer leur production en circuits courts.
  9. *
  10. * Ce logiciel est régi par la licence CeCILL soumise au droit français et
  11. * respectant les principes de diffusion des logiciels libres. Vous pouvez
  12. * utiliser, modifier et/ou redistribuer ce programme sous les conditions
  13. * de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
  14. * sur le site "http://www.cecill.info".
  15. *
  16. * En contrepartie de l'accessibilité au code source et des droits de copie,
  17. * de modification et de redistribution accordés par cette licence, il n'est
  18. * offert aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons,
  19. * seule une responsabilité restreinte pèse sur l'auteur du programme, le
  20. * titulaire des droits patrimoniaux et les concédants successifs.
  21. *
  22. * A cet égard l'attention de l'utilisateur est attirée sur les risques
  23. * associés au chargement, à l'utilisation, à la modification et/ou au
  24. * développement et à la reproduction du logiciel par l'utilisateur étant
  25. * donné sa spécificité de logiciel libre, qui peut le rendre complexe à
  26. * manipuler et qui le réserve donc à des développeurs et des professionnels
  27. * avertis possédant des connaissances informatiques approfondies. Les
  28. * utilisateurs sont donc invités à charger et tester l'adéquation du
  29. * logiciel à leurs besoins dans des conditions permettant d'assurer la
  30. * sécurité de leurs systèmes et ou de leurs données et, plus généralement,
  31. * à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.
  32. *
  33. * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
  34. * pris connaissance de la licence CeCILL, et que vous en avez accepté les
  35. * termes.
  36. */
  37. namespace common\models;
  38. use common\helpers\GlobalParam;
  39. use yii\web\IdentityInterface;
  40. use yii\db\Query;
  41. use common\components\ActiveRecordCommon;
  42. /**
  43. * User model
  44. *
  45. * @property integer $id
  46. * @property string $username
  47. * @property string $password_hash
  48. * @property string $password_reset_token
  49. * @property string $email
  50. * @property string $auth_key
  51. * @property integer $status
  52. * @property integer $created_at
  53. * @property integer $updated_at
  54. * @property string $password write-only password
  55. * @property boolean $confiance
  56. */
  57. class User extends ActiveRecordCommon implements IdentityInterface
  58. {
  59. const TYPE_INDIVIDUAL = 'individual' ;
  60. const TYPE_LEGAL_PERSON = 'legal-person' ;
  61. const STATUS_DELETED = 0;
  62. const STATUS_ACTIVE = 10;
  63. const STATUS_PRODUCER = 11;
  64. const STATUS_ADMIN = 13;
  65. const ID_USER_SYSTEM = 0;
  66. var $password_old;
  67. var $password_new;
  68. var $password_new_confirm;
  69. var $points_sale = [];
  70. var $user_groups = [];
  71. var $one_name ;
  72. var $product_price_percent ;
  73. /**
  74. * @inheritdoc
  75. */
  76. public static function tableName()
  77. {
  78. return '{{%user}}';
  79. }
  80. /**
  81. * @inheritdoc
  82. */
  83. public function behaviors()
  84. {
  85. return [
  86. TimestampBehavior::className(),
  87. ];
  88. }
  89. /**
  90. * @inheritdoc
  91. */
  92. public function rules()
  93. {
  94. return [
  95. [['no_mail', 'mail_distribution_monday', 'mail_distribution_tuesday', 'mail_distribution_wednesday', 'mail_distribution_thursday', 'mail_distribution_friday', 'mail_distribution_saturday', 'mail_distribution_sunday', 'is_main_contact'], 'boolean'],
  96. [['lastname', 'name', 'phone', 'address', 'type', 'name_legal_person'], 'string'],
  97. ['lastname', 'verifyOneName', 'skipOnError' => false, 'skipOnEmpty' => false],
  98. ['email', 'email', 'message' => 'Cette adresse email n\'est pas valide'],
  99. ['email', 'verifyEmail'],
  100. ['status', 'default', 'value' => self::STATUS_ACTIVE],
  101. ['status', 'in', 'range' => [self::STATUS_ACTIVE, self::STATUS_DELETED, self::STATUS_ADMIN, self::STATUS_PRODUCER]],
  102. ['password_old', 'verifyPasswordOld'],
  103. ['password_new', 'verifyPasswordNew'],
  104. ['password_new_confirm', 'verifyPasswordNewConfirm'],
  105. [['date_last_connection', 'password_old', 'password_new', 'password_new_confirm', 'password_hash', 'points_sale', 'product_price_percent', 'user_groups'], 'safe'],
  106. ];
  107. }
  108. public function attributeLabels()
  109. {
  110. return [
  111. 'id' => 'ID',
  112. 'name' => 'Prénom',
  113. 'lastname' => 'Nom',
  114. 'phone' => 'Téléphone',
  115. 'address' => 'Adresse',
  116. 'username' => 'Identifiant',
  117. 'password' => 'Mot de passe',
  118. 'rememberMe' => 'Se souvenir de moi',
  119. 'no_mail' => 'Ne pas recevoir d\'email de la part du Chat des Noisettes',
  120. 'mail_distribution_monday' => 'Lundi',
  121. 'mail_distribution_tuesday' => 'Mardi',
  122. 'mail_distribution_wednesday' => 'Mercredi',
  123. 'mail_distribution_thursday' => 'Jeudi',
  124. 'mail_distribution_friday' => 'Vendredi',
  125. 'mail_distribution_saturday' => 'Samedi',
  126. 'mail_distribution_sunday' => 'Dimanche',
  127. 'password_old' => 'Ancien mot de passe',
  128. 'password_new' => 'Nouveau mot de passe',
  129. 'password_new_confirm' => 'Confirmation du nouveau mot de passe',
  130. 'points_sale' => 'Points de vente',
  131. 'type' => 'Type',
  132. 'name_legal_person' => 'Libellé',
  133. 'is_main_contact' => 'Contact principal',
  134. 'product_price_percent' => 'Prix produits : pourcentage',
  135. 'user_groups' => "Groupes d'utilisateurs"
  136. ];
  137. }
  138. /**
  139. * Retourne les options de base nécessaires à la fonction de recherche.
  140. *
  141. * @return array
  142. */
  143. public static function defaultOptionsSearch()
  144. {
  145. return [
  146. 'with' => [],
  147. 'join_with' => ['userProducer', 'userUserGroup'],
  148. 'orderby' => 'user.name ASC, user.lastname ASC',
  149. 'attribute_id_producer' => ''
  150. ];
  151. }
  152. /**
  153. * Vérifie le mot de passe envoyé par l'utilisateur.
  154. *
  155. * @param string $attribute
  156. * @param array $params
  157. */
  158. public function verifyPasswordOld($attribute, $params)
  159. {
  160. if (strlen($this->password_old)) {
  161. if (!$this->validatePassword($this->password_old)) {
  162. $this->addError($attribute, 'Mot de passe invalide.');
  163. }
  164. }
  165. if (!strlen($this->password_old) && (strlen($this->password_new) || strlen($this->password_new_confirm))) {
  166. $this->addError($attribute, 'Ce champs ne peut être vide');
  167. }
  168. if (!strlen($this->password_new) && (strlen($this->password_old) || strlen($this->password_new_confirm))) {
  169. $this->addError('password_new', 'Ce champs ne peut être vide');
  170. }
  171. if (!strlen($this->password_new_confirm) && (strlen($this->password_old) || strlen($this->password_new))) {
  172. $this->addError('password_new_confirm', 'Ce champs ne peut être vide');
  173. }
  174. }
  175. /**
  176. * Vérifie le mot de passe de l'utilisateur.
  177. *
  178. * @param string $attribute
  179. * @param array $params
  180. */
  181. public function verifyPasswordNew($attribute, $params)
  182. {
  183. if (strlen($this->password_new) < 6) {
  184. $this->addError($attribute, 'Votre mot de passe doit comporter au moins 6 caractères.');
  185. }
  186. }
  187. /**
  188. * Vérifie la confirmation de mot de passe de l'utilisateur.
  189. *
  190. * @param string $attribute
  191. * @param array $params
  192. */
  193. public function verifyPasswordNewConfirm($attribute, $params)
  194. {
  195. if ($this->password_new != $this->password_new_confirm) {
  196. $this->addError($attribute, 'Les deux mots de passe doivent être identiques');
  197. }
  198. }
  199. /**
  200. * Vérifie l'email de l'utilisateur.
  201. *
  202. * @param string $attribute
  203. * @param array $params
  204. */
  205. public function verifyEmail($attribute, $params)
  206. {
  207. if($this->id) {
  208. $user = User::find()->where("email LIKE :email AND id != :id")->params(array(':email' => '%' . $this->email . '%', ':id' => $this->id))->one();
  209. }
  210. else {
  211. $user = User::find()->where("email LIKE :email")->params(array(':email' => '%' . $this->email . '%'))->one();
  212. }
  213. if ($user) {
  214. $this->addError($attribute, 'Cette adresse email est déjà utilisée par un autre utilisateur ');
  215. }
  216. }
  217. /**
  218. * Vérifie que l'utilisateur a au moins un nom de défini
  219. *
  220. * @param $attribute
  221. * @param $params
  222. */
  223. public function verifyOneName($attribute, $params)
  224. {
  225. if(strlen($this->lastname) == 0 && strlen($this->name_legal_person) == 0) {
  226. $this->addError('lastname', 'Vous devez saisir au moins un nom.');
  227. $this->addError('name_legal_person', 'Vous devez saisir au moins un nom.');
  228. }
  229. }
  230. /*
  231. * Relations
  232. */
  233. public function getUserProducer()
  234. {
  235. return $this->hasMany(UserProducer::className(), ['id_user' => 'id']);
  236. }
  237. public function getUserUserGroup()
  238. {
  239. return $this->hasMany(UserUserGroup::className(), ['id_user' => 'id']);
  240. }
  241. public function getOrder()
  242. {
  243. return $this->hasMany(Order::className(), ['id_user' => 'id']);
  244. }
  245. /**
  246. * @inheritdoc
  247. */
  248. public static function findIdentity($id)
  249. {
  250. return static::findOne(['id' => $id]);
  251. }
  252. /**
  253. * @inheritdoc
  254. */
  255. public static function findIdentityByAccessToken($token, $type = null)
  256. {
  257. throw new NotSupportedException('"findIdentityByAccessToken" is not implemented.');
  258. }
  259. /**
  260. * Finds user by username
  261. *
  262. * @param string $username
  263. * @return static|null
  264. */
  265. public static function findByUsername($username)
  266. {
  267. return static::findOne(['username' => $username]);
  268. }
  269. /**
  270. * Recherche un utilisateur via son adresse email.
  271. *
  272. * @param string $email
  273. * @return User
  274. */
  275. public static function findByEmail($email)
  276. {
  277. return static::findOne(['email' => $email]);
  278. }
  279. /**
  280. * Finds user by password reset token
  281. *
  282. * @param string $token password reset token
  283. * @return static|null
  284. */
  285. public static function findByPasswordResetToken($token)
  286. {
  287. if (!static::isPasswordResetTokenValid($token)) {
  288. return null;
  289. }
  290. return static::findOne([
  291. 'password_reset_token' => $token,
  292. ]);
  293. }
  294. /**
  295. * Recherche des utilisateurs suivant les paramètres : id_etablissement,
  296. * inactifs, id_point_vente, nom, prenom, email, telephone.
  297. *
  298. * @param array $params
  299. * @return Query
  300. */
  301. public static function findBy($params = [])
  302. {
  303. if (!isset($params['id_producer'])) {
  304. $params['id_producer'] = GlobalParam::getCurrentProducerId();
  305. }
  306. $query = (new Query())
  307. ->select(['user.id AS user_id', 'user.name', 'user.lastname', 'user.phone', 'user.email', 'user.created_at', 'user.date_last_connection', 'user_producer.*', 'user.address', 'user.name_legal_person'])
  308. ->from('user');
  309. $active = (isset($params['inactive']) && $params['inactive']) ? 0 : 1;
  310. $query->innerJoin('user_producer', 'user.id = user_producer.id_user AND user_producer.active = ' . $active . ' AND user_producer.id_producer = :id_producer', [':id_producer' => $params['id_producer']]);
  311. if (isset($params['id_point_sale']) && $params['id_point_sale']) {
  312. $point_sale = PointSale::findOne(['id' => $params['id_point_sale']]);
  313. $conditionLinkUserPointSale = 'user.id = user_point_sale.id_user AND user_point_sale.id_point_sale = :id_point_sale';
  314. $usersPointSaleLink = false;
  315. $usersPointSaleHasOrder = false;
  316. if (isset($params['users_point_sale_link']) && $params['users_point_sale_link']) {
  317. $usersPointSaleLink = true;
  318. } elseif (isset($params['users_point_sale_has_order']) && $params['users_point_sale_has_order']) {
  319. $usersPointSaleHasOrder = true;
  320. } elseif ($point_sale->restricted_access) {
  321. $usersPointSaleLink = true;
  322. } else {
  323. $usersPointSaleHasOrder = true;
  324. }
  325. if ($usersPointSaleLink) {
  326. $query->innerJoin('user_point_sale', 'user.id = user_point_sale.id_user AND user_point_sale.id_point_sale = :id_point_sale', [':id_point_sale' => $params['id_point_sale']]);
  327. } elseif ($usersPointSaleHasOrder) {
  328. $query->innerJoin(
  329. 'order',
  330. 'user.id = order.id_user AND order.id_point_sale = :id_point_sale',
  331. [':id_point_sale' => $params['id_point_sale']]
  332. )->groupBy('user.id');
  333. }
  334. }
  335. if (isset($params['subscribers']) && $params['subscribers']) {
  336. $query->innerJoin(
  337. 'subscription',
  338. 'user.id = subscription.id_user AND subscription.id_producer = :id_producer',
  339. [':id_producer' => GlobalParam::getCurrentProducerId()]
  340. )->groupBy('user.id');
  341. }
  342. if (isset($params['inactive']) && $params['inactive']) {
  343. $query->innerJoin(
  344. 'order',
  345. 'user.id = order.id_user'
  346. )
  347. ->groupBy('user.id');
  348. }
  349. if (isset($params['name'])) {
  350. $query->andFilterWhere(['like', 'name', $params['name']]);
  351. }
  352. if (isset($params['lastname'])) {
  353. $query->andFilterWhere(['like', 'lastname', $params['lastname']]);
  354. }
  355. if (isset($params['email'])) {
  356. $query->andFilterWhere(['like', 'email', $params['email']]);
  357. }
  358. if (isset($params['phone'])) {
  359. $query->andFilterWhere(['like', 'phone', $params['phone']]);
  360. }
  361. $query->orderBy('user.type DESC, user.lastname ASC, user.name ASC');
  362. return $query;
  363. }
  364. /**
  365. * Finds out if password reset token is valid
  366. *
  367. * @param string $token password reset token
  368. * @return boolean
  369. */
  370. public static function isPasswordResetTokenValid($token)
  371. {
  372. if (empty($token)) {
  373. return false;
  374. }
  375. $expire = Yii::$app->params['user.passwordResetTokenExpire'];
  376. $parts = explode('_', $token);
  377. $timestamp = (int)end($parts);
  378. return $timestamp + $expire >= time();
  379. }
  380. /**
  381. * @inheritdoc
  382. */
  383. public function getId()
  384. {
  385. return $this->getPrimaryKey();
  386. }
  387. /**
  388. * @inheritdoc
  389. */
  390. public function getAuthKey()
  391. {
  392. return $this->auth_key;
  393. }
  394. /**
  395. * @inheritdoc
  396. */
  397. public function validateAuthKey($authKey)
  398. {
  399. return $this->getAuthKey() === $authKey;
  400. }
  401. /**
  402. * Validates password
  403. *
  404. * @param string $password password to validate
  405. * @return boolean if password provided is valid for current user
  406. */
  407. public function validatePassword($password)
  408. {
  409. return Yii::$app->security->validatePassword($password, $this->password_hash);
  410. }
  411. /**
  412. * Generates password hash from password and sets it to the model
  413. *
  414. * @param string $password
  415. */
  416. public function setPassword($password)
  417. {
  418. $this->password_hash = Yii::$app->security->generatePasswordHash($password);
  419. }
  420. /**
  421. * Generates "remember me" authentication key
  422. */
  423. public function generateAuthKey()
  424. {
  425. $this->auth_key = Yii::$app->security->generateRandomString();
  426. }
  427. /**
  428. * Generates new password reset token
  429. */
  430. public function generatePasswordResetToken()
  431. {
  432. $this->password_reset_token = Yii::$app->security->generateRandomString() . '_' . time();
  433. }
  434. /**
  435. * Removes password reset token
  436. */
  437. public function removePasswordResetToken()
  438. {
  439. $this->password_reset_token = null;
  440. }
  441. /**
  442. * Retourne l'utilisateur courant.
  443. *
  444. * @return User
  445. */
  446. public static function getCurrent()
  447. {
  448. if (!Yii::$app->user->isGuest) {
  449. return Yii::$app->user->identity;
  450. }
  451. return false;
  452. }
  453. /**
  454. * Retourne si l'utilisateur courant est connecté ou non.
  455. *
  456. * @return boolean
  457. */
  458. public static function isCurrentConnected()
  459. {
  460. return !Yii::$app->user->isGuest;
  461. }
  462. /**
  463. * Retourne si l'utilisateur est un producteur ou non.
  464. *
  465. * @return boolean
  466. */
  467. public function isProducer()
  468. {
  469. return ($this->status == User::STATUS_ADMIN || $this->status == User::STATUS_PRODUCER) && $this->id_producer;
  470. }
  471. /**
  472. * Retourne si l'utilisateur courant est un producteur ou non.
  473. *
  474. * @return boolean
  475. */
  476. public static function isCurrentProducer()
  477. {
  478. $user = User::getCurrent();
  479. if ($user) {
  480. return $user->isProducer();
  481. }
  482. return false;
  483. }
  484. /**
  485. * Retourne si l'utilisateur est un admin ou non.
  486. *
  487. * @return boolean
  488. */
  489. public function isAdmin()
  490. {
  491. return $this->status == User::STATUS_ADMIN;
  492. }
  493. /**
  494. * Retourne si l'utilisateur courant est un admin ou non.
  495. *
  496. * @return boolean
  497. */
  498. public static function isCurrentAdmin()
  499. {
  500. $user = User::getCurrent();
  501. if ($user) {
  502. return $user->isAdmin();
  503. }
  504. return false;
  505. }
  506. /**
  507. * Retourne le nom du producteur.
  508. *
  509. * @return string
  510. */
  511. public function getNameProducer()
  512. {
  513. $producer = Producer::findOne($this->id_producer);
  514. return $producer->name;
  515. }
  516. /**
  517. * Retourne les établissements liés à l'utilisateur.
  518. *
  519. * @return array
  520. */
  521. public function getBookmarkedProducers()
  522. {
  523. $producers = (new \yii\db\Query())
  524. ->select('*')
  525. ->from(['user_producer', 'producer'])
  526. ->where('user_producer.id_producer = producer.id')
  527. ->andWhere(['user_producer.id_user' => $this->id])
  528. ->andWhere(['user_producer.active' => 1])
  529. ->all();
  530. return $producers;
  531. }
  532. /**
  533. * Retourne le crédit de l'utilisateur pour un producteur donné.
  534. *
  535. * @param integer $id_etablissement
  536. * @return float
  537. */
  538. public function getCredit($idProducer)
  539. {
  540. $userProducer = UserProducer::searchOne([
  541. 'id_user' => $this->id
  542. ]);
  543. if ($userProducer) {
  544. return $userProducer->credit;
  545. }
  546. return 0;
  547. }
  548. /**
  549. * Retourne le point de vente favoris d'un utilisateur : le point de vente auquel le client est lié,
  550. * le point de vente de la dernière commande sinon.
  551. *
  552. * @return PointSale
  553. */
  554. public function getFavoritePointSale()
  555. {
  556. $arrayUserPointSale = UserPointSale::find()
  557. ->innerJoinWith('pointSale', true)
  558. ->where([
  559. 'user_point_sale.id_user' => $this->id,
  560. 'point_sale.id_producer' => GlobalParam::getCurrentProducerId()
  561. ])
  562. ->all();
  563. if (count($arrayUserPointSale) == 1) {
  564. $pointSale = PointSale::findOne(['id' => $arrayUserPointSale[0]->id_point_sale]);
  565. } else {
  566. $lastOrder = Order::find()->innerJoinWith('pointSale', true)->where([
  567. 'order.id_user' => $this->id,
  568. 'point_sale.id_producer' => GlobalParam::getCurrentProducerId()
  569. ])
  570. ->orderBy('order.id DESC')
  571. ->one();
  572. if ($lastOrder) {
  573. $pointSale = PointSale::findOne(['id' => $lastOrder->id_point_sale]);
  574. }
  575. }
  576. if (isset($pointSale)) {
  577. return $pointSale;
  578. }
  579. return false;
  580. }
  581. /**
  582. * Met à jour la date de dernière connexion de l'utilisateur.
  583. */
  584. public function updateLastConnection()
  585. {
  586. $this->date_last_connection = date('Y-m-d H:i:s');
  587. $this->save();
  588. }
  589. /**
  590. * Envoie un email de bienvenue à l'utilisateur lors de son inscription
  591. * via le backend du site.
  592. *
  593. * @param string $password
  594. */
  595. public function sendMailWelcome($password)
  596. {
  597. if (strlen($this->email)) {
  598. $producer = Producer::findOne(GlobalParam::getCurrentProducerId());
  599. Yii::$app->mailer->compose();
  600. $mail = Yii::$app->mailer->compose(
  601. ['html' => 'createUserAdmin-html', 'text' => 'createUserAdmin-text'], ['user' => $this, 'producer' => $producer, 'password' => $password]
  602. )
  603. ->setTo($this->email)
  604. ->setFrom(['contact@opendistrib.net' => 'distrib'])
  605. ->setSubject('[distrib] Inscription')
  606. ->send();
  607. }
  608. }
  609. public function getFullAddress($nl2br = false)
  610. {
  611. $address = '';
  612. if(isset($this->lastname) && isset($this->name) && strlen($this->lastname) && strlen($this->name)) {
  613. $address .= $this->lastname . ' ' . $this->name . "\n";
  614. }
  615. if(isset($this->name_legal_person) && strlen($this->name_legal_person)) {
  616. $address .= $this->name_legal_person. "\n";
  617. }
  618. $address .= $this->address;
  619. if($nl2br) {
  620. $address = nl2br($address) ;
  621. }
  622. return $address;
  623. }
  624. public function getUsername($withType = false)
  625. {
  626. $username = '' ;
  627. if(isset($this->name_legal_person) && strlen($this->name_legal_person)) {
  628. $username = $this->name_legal_person ;
  629. if($withType) {
  630. $username = 'Personne morale / '.$username ;
  631. }
  632. }
  633. else {
  634. $username = $this->lastname.' '.$this->name ;
  635. }
  636. return $username ;
  637. }
  638. public static function getUsernameFromArray($modelArray, $withType = false)
  639. {
  640. $username = '' ;
  641. if(isset($modelArray['name_legal_person']) && strlen($modelArray['name_legal_person'])) {
  642. $username = $modelArray['name_legal_person'] ;
  643. if($withType) {
  644. $username = 'Personne morale / '.$username ;
  645. }
  646. }
  647. else {
  648. $username = $modelArray['lastname'].' '.$modelArray['name'] ;
  649. }
  650. return $username ;
  651. }
  652. public static function populateDropdownList()
  653. {
  654. $usersArray = User::findBy()->all() ;
  655. $usersArrayDropdown = ['' => '--'] ;
  656. foreach($usersArray as $user) {
  657. $usersArrayDropdown[$user['user_id']] = User::getUsernameFromArray($user, true) ;
  658. }
  659. return $usersArrayDropdown ;;
  660. }
  661. /**
  662. * Retourne l'ID de l'utilisateur courant connecté.
  663. *
  664. * @return mixed
  665. */
  666. public static function getCurrentId()
  667. {
  668. if (!Yii::$app->user->isGuest) {
  669. return Yii::$app->user->identity->id;
  670. }
  671. return false;
  672. }
  673. /**
  674. * Retourne le status de l'utilisateur courant connecté.
  675. *
  676. * @return integer|boolean
  677. */
  678. public static function getCurrentStatus()
  679. {
  680. if (!Yii::$app->user->isGuest) {
  681. return Yii::$app->user->identity->status;
  682. }
  683. return false;
  684. }
  685. public static function hasAccessBackend()
  686. {
  687. return User::getCurrentStatus() == USER::STATUS_ADMIN || User::getCurrentStatus() == USER::STATUS_PRODUCER;
  688. }
  689. public function belongsToUserGroup($userGroupId)
  690. {
  691. if(!$this->userUserGroup) {
  692. $this->populateRelation('userUserGroup', UserUserGroup::searchAll([
  693. 'id_user' => $this->id
  694. ])) ;
  695. }
  696. if($this->userUserGroup) {
  697. foreach($this->userUserGroup as $userUserGroup) {
  698. if($userUserGroup->id_user_group == $userGroupId) {
  699. return true ;
  700. }
  701. }
  702. }
  703. return false ;
  704. }
  705. }