Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.

620 lines
18KB

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