Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.

739 rindas
26KB

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