You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

549 lines
16KB

  1. <?php
  2. /**
  3. Copyright La boîte à pain (2018)
  4. contact@laboiteapain.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. /**
  61. * @inheritdoc
  62. */
  63. public static function tableName()
  64. {
  65. return '{{%user}}';
  66. }
  67. /**
  68. * @inheritdoc
  69. */
  70. public function behaviors()
  71. {
  72. return [
  73. TimestampBehavior::className(),
  74. ];
  75. }
  76. /**
  77. * @inheritdoc
  78. */
  79. public function rules()
  80. {
  81. return [
  82. ['confiance', 'default', 'value' => 1],
  83. [['no_mail', 'mail_prod_lundi', 'mail_prod_mardi', 'mail_prod_mercredi', 'mail_prod_jeudi', 'mail_prod_vendredi', 'mail_prod_samedi', 'mail_prod_dimanche'], 'boolean'],
  84. [['nom', 'prenom', 'telephone', 'adresse'], 'string'],
  85. [['nom', 'prenom'], '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_BOULANGER]],
  90. ['password_old', 'verifyPasswordOld'],
  91. ['password_new', 'verifyPasswordNew'],
  92. ['password_new_confirm', 'verifyPasswordNewConfirm'],
  93. [['date_derniere_connexion', 'password_old', 'password_new', 'password_new_confirm', 'password_hash'], 'safe'],
  94. ];
  95. }
  96. public function attributeLabels()
  97. {
  98. return [
  99. 'id' => 'ID',
  100. 'username' => 'Identifiant',
  101. 'password' => 'Mot de passe',
  102. 'rememberMe' => 'Se souvenir de moi',
  103. 'confiance' => 'De confiance',
  104. 'no_mail' => 'Ne pas recevoir d\'email de la part du Chat des Noisettes',
  105. 'mail_prod_lundi' => 'Lundi',
  106. 'mail_prod_mardi' => 'Mardi',
  107. 'mail_prod_mercredi' => 'Mercredi',
  108. 'mail_prod_jeudi' => 'Jeudi',
  109. 'mail_prod_vendredi' => 'Vendredi',
  110. 'mail_prod_samedi' => 'Samedi',
  111. 'mail_prod_dimanche' => 'Dimanche',
  112. 'password_old' => 'Ancien mot de passe',
  113. 'password_new' => 'Nouveau mot de passe',
  114. 'password_new_confirm' => 'Confirmation du nouveau mot de passe',
  115. 'prix_libre' => 'Prix libre',
  116. ];
  117. }
  118. /**
  119. * Retourne les options de base nécessaires à la fonction de recherche.
  120. *
  121. * @return array
  122. */
  123. public static function defaultOptionsSearch() {
  124. return [
  125. 'with' => [],
  126. 'join_with' => ['userEtablissement'],
  127. 'orderby' => 'user.name ASC, user.lastname ASC',
  128. 'attribute_id_producer' => ''
  129. ] ;
  130. }
  131. /**
  132. * Vérifie le mot de passe envoyé par l'utilisateur.
  133. *
  134. * @param string $attribute
  135. * @param array $params
  136. */
  137. public function verifyPasswordOld($attribute, $params)
  138. {
  139. if (strlen($this->password_old)) {
  140. if (!$this->validatePassword($this->password_old)) {
  141. $this->addError($attribute, 'Mot de passe invalide.');
  142. }
  143. }
  144. if (!strlen($this->password_old) && (strlen($this->password_new) || strlen($this->password_new_confirm))) {
  145. $this->addError($attribute, 'Ce champs ne peut être vide');
  146. }
  147. if (!strlen($this->password_new) && (strlen($this->password_old) || strlen($this->password_new_confirm))) {
  148. $this->addError('password_new', 'Ce champs ne peut être vide');
  149. }
  150. if (!strlen($this->password_new_confirm) && (strlen($this->password_old) || strlen($this->password_new))) {
  151. $this->addError('password_new_confirm', 'Ce champs ne peut être vide');
  152. }
  153. }
  154. /**
  155. * Vérifie le mot de passe de l'utilisateur.
  156. *
  157. * @param string $attribute
  158. * @param array $params
  159. */
  160. public function verifyPasswordNew($attribute, $params)
  161. {
  162. if (strlen($this->password_new) < 6) {
  163. $this->addError($attribute, 'Votre mot de passe doit comporter au moins 6 caractères.');
  164. }
  165. }
  166. /**
  167. * Vérifie la confirmation de mot de passe de l'utilisateur.
  168. *
  169. * @param string $attribute
  170. * @param array $params
  171. */
  172. public function verifyPasswordNewConfirm($attribute, $params)
  173. {
  174. if ($this->password_new != $this->password_new_confirm) {
  175. $this->addError($attribute, 'Les deux mots de passe doivent être identiques');
  176. }
  177. }
  178. /**
  179. * Vérifie l'email de l'utilisateur.
  180. *
  181. * @param string $attribute
  182. * @param array $params
  183. */
  184. public function verifyEmail($attribute, $params)
  185. {
  186. $user = User::find()->where("email LIKE :email AND id != :id")->params(array(':email' => '%' . $this->email . '%', ':id' => $this->id))->one();
  187. if ($user) {
  188. $this->addError($attribute, 'Cette adresse email est déjà utilisée par un autre utilisateur ');
  189. }
  190. }
  191. /*
  192. * Relations
  193. */
  194. public function getUserProducer()
  195. {
  196. return $this->hasMany(UserProducer::className(), ['id_user' => 'id']);
  197. }
  198. /**
  199. * @inheritdoc
  200. */
  201. public static function findIdentity($id)
  202. {
  203. return static::findOne(['id' => $id]);
  204. }
  205. /**
  206. * @inheritdoc
  207. */
  208. public static function findIdentityByAccessToken($token, $type = null)
  209. {
  210. throw new NotSupportedException('"findIdentityByAccessToken" is not implemented.');
  211. }
  212. /**
  213. * Finds user by username
  214. *
  215. * @param string $username
  216. * @return static|null
  217. */
  218. public static function findByUsername($username)
  219. {
  220. return static::findOne(['username' => $username]);
  221. }
  222. /**
  223. * Recherche un utilisateur via son adresse email.
  224. *
  225. * @param string $email
  226. * @return User
  227. */
  228. public static function findByEmail($email)
  229. {
  230. return static::findOne(['email' => $email]);
  231. }
  232. /**
  233. * Finds user by password reset token
  234. *
  235. * @param string $token password reset token
  236. * @return static|null
  237. */
  238. public static function findByPasswordResetToken($token)
  239. {
  240. if (!static::isPasswordResetTokenValid($token)) {
  241. return null;
  242. }
  243. return static::findOne([
  244. 'password_reset_token' => $token,
  245. ]);
  246. }
  247. /**
  248. * Recherche des utilisateurs suivant les paramètres : id_etablissement,
  249. * inactifs, id_point_vente, nom, prenom, email, telephone.
  250. *
  251. * @param array $params
  252. * @return Query
  253. */
  254. public static function findBy($params = [])
  255. {
  256. if (!isset($params['id_producer'])) {
  257. $params['id_producer'] = Producer::getId() ;
  258. }
  259. $query = (new Query())
  260. ->select(['user.id AS user_id', 'user.name', 'user.lastname', 'user.phone', 'user.email', 'user.created_at', 'user.date_last_connection', 'user_producer.*'])
  261. ->from('user');
  262. $active = (isset($params['inactive']) && $params['inactive']) ? 0 : 1 ;
  263. $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']]) ;
  264. if(isset($params['id_point_sale']) && $params['id_point_sale']) {
  265. $point_sale = PointSale::findOne(['id' => $params['id_point_sale']]) ;
  266. if($point_sale->restricted_access) {
  267. $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']]) ;
  268. }
  269. else {
  270. $query->innerJoin(
  271. 'order',
  272. 'user.id = order.id_user AND order.id_point_sale = :id_point_sale',
  273. [':id_point_sale' => $params['id_point_sale']]
  274. )->groupBy('user.id') ;
  275. }
  276. }
  277. if(isset($params['inactive']) && $params['inactive']) {
  278. $query->innerJoin(
  279. 'order',
  280. 'user.id = order.id_user'
  281. )
  282. ->groupBy('user.id');
  283. }
  284. if (isset($params['name'])) {
  285. $query->andFilterWhere(['like', 'name', $params['name']]);
  286. }
  287. if (isset($params['lastname'])) {
  288. $query->andFilterWhere(['like', 'lastname', $params['lastname']]);
  289. }
  290. if (isset($params['email'])) {
  291. $query->andFilterWhere(['like', 'email', $params['email']]);
  292. }
  293. if (isset($params['phone'])) {
  294. $query->andFilterWhere(['like', 'phone', $params['phone']]);
  295. }
  296. return $query;
  297. }
  298. /**
  299. * Finds out if password reset token is valid
  300. *
  301. * @param string $token password reset token
  302. * @return boolean
  303. */
  304. public static function isPasswordResetTokenValid($token)
  305. {
  306. if (empty($token)) {
  307. return false;
  308. }
  309. $expire = Yii::$app->params['user.passwordResetTokenExpire'];
  310. $parts = explode('_', $token);
  311. $timestamp = (int) end($parts);
  312. return $timestamp + $expire >= time();
  313. }
  314. /**
  315. * @inheritdoc
  316. */
  317. public function getId()
  318. {
  319. return $this->getPrimaryKey();
  320. }
  321. /**
  322. * @inheritdoc
  323. */
  324. public function getAuthKey()
  325. {
  326. return $this->auth_key;
  327. }
  328. /**
  329. * @inheritdoc
  330. */
  331. public function validateAuthKey($authKey)
  332. {
  333. return $this->getAuthKey() === $authKey;
  334. }
  335. /**
  336. * Validates password
  337. *
  338. * @param string $password password to validate
  339. * @return boolean if password provided is valid for current user
  340. */
  341. public function validatePassword($password)
  342. {
  343. return Yii::$app->security->validatePassword($password, $this->password_hash);
  344. }
  345. /**
  346. * Generates password hash from password and sets it to the model
  347. *
  348. * @param string $password
  349. */
  350. public function setPassword($password)
  351. {
  352. $this->password_hash = Yii::$app->security->generatePasswordHash($password);
  353. }
  354. /**
  355. * Generates "remember me" authentication key
  356. */
  357. public function generateAuthKey()
  358. {
  359. $this->auth_key = Yii::$app->security->generateRandomString();
  360. }
  361. /**
  362. * Generates new password reset token
  363. */
  364. public function generatePasswordResetToken()
  365. {
  366. $this->password_reset_token = Yii::$app->security->generateRandomString() . '_' . time();
  367. }
  368. /**
  369. * Removes password reset token
  370. */
  371. public function removePasswordResetToken()
  372. {
  373. $this->password_reset_token = null;
  374. }
  375. /**
  376. * Retourne si l'utilisateur est un boulanger ou non.
  377. *
  378. * @return boolean
  379. */
  380. public function isProducer()
  381. {
  382. return ($this->status == User::STATUS_ADMIN || $this->status == User::STATUS_PRODUCER) && $this->id_producer;
  383. }
  384. /**
  385. * Retourne le nom du producteur.
  386. *
  387. * @return string
  388. */
  389. public function getNameProducer()
  390. {
  391. $producer = Producer::findOne($this->id_producer);
  392. return $producer->name;
  393. }
  394. /**
  395. * Retourne les établissements liés à l'utilisateur.
  396. *
  397. * @return array
  398. */
  399. public function getBookmarkedProducers()
  400. {
  401. $producers = (new \yii\db\Query())
  402. ->select('*')
  403. ->from(['user_producer', 'producer'])
  404. ->where('user_producer.id_producer = producer.id')
  405. ->andWhere(['user_producer.id_user' => $this->id])
  406. ->andWhere(['user_producer.active' => 1])
  407. ->all();
  408. return $producers;
  409. }
  410. /**
  411. * Retourne le crédit de l'utilisateur pour un producteur donné.
  412. *
  413. * @param integer $id_etablissement
  414. * @return float
  415. */
  416. public function getCredit($idProducer)
  417. {
  418. $userProducer = UserProducer::searchOne([
  419. 'id_user' => $this->id
  420. ]) ;
  421. if ($userProducer) {
  422. return $userProducer->credit;
  423. }
  424. return 0;
  425. }
  426. /**
  427. * Met à jour la date de dernière connexion de l'utilisateur.
  428. */
  429. public function updateLastConnection()
  430. {
  431. $this->date_last_connection = date('Y-m-d H:i:s');
  432. $this->save();
  433. }
  434. /**
  435. * Envoie un email de bienvenue à l'utilisateur lors de son inscription
  436. * via le backend du site.
  437. *
  438. * @param string $password
  439. */
  440. public function sendMailWelcome($password)
  441. {
  442. if (strlen($this->email)) {
  443. $producer = Producer::findOne(Producer::getId());
  444. Yii::$app->mailer->compose();
  445. $mail = Yii::$app->mailer->compose(
  446. ['html' => 'createUserAdmin-html', 'text' => 'createUserAdmin-text'], ['user' => $this, 'producer' => $producer, 'password' => $password]
  447. )
  448. ->setTo($this->email)
  449. ->setFrom(['contact@laboiteapain.net' => 'La boîte à pain'])
  450. ->setSubject('[La boîte à pain] Inscription')
  451. ->send();
  452. }
  453. }
  454. /**
  455. * Retourne l'ID de l'utilisateur courant connecté.
  456. *
  457. * @return mixed
  458. */
  459. public static function getId() {
  460. if(!Yii::$app->user->isGuest) {
  461. return Yii::$app->user->identity->id ;
  462. }
  463. return false ;
  464. }
  465. /**
  466. * Retourne le status de l'utilisateur courant connecté.
  467. *
  468. * @return integer|boolean
  469. */
  470. public static function getStatus()
  471. {
  472. if(!Yii::$app->user->isGuest) {
  473. return Yii::$app->user->identity->status ;
  474. }
  475. return false ;
  476. }
  477. public static function hasAccessBackend()
  478. {
  479. return User::getStatus() == USER::STATUS_ADMIN || User::getStatus() == USER::STATUS_PRODUCER;
  480. }
  481. }