Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.

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