383 lines
11KB

  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;
  33. use common\components\ActiveRecordCommon ;
  34. use yii\db\ActiveRecord;
  35. use common\models\User;
  36. use common\models\Order;
  37. use common\models\Producer;
  38. use yii\helpers\Html;
  39. /**
  40. * This is the model class for table "credit_historique".
  41. *
  42. * @property integer $id
  43. * @property integer $id_user
  44. * @property integer $id_order
  45. * @property string $date
  46. * @property double $amount
  47. * @property string $type
  48. * @property integer $id_producer
  49. * @property string $mean_payment
  50. */
  51. class CreditHistory extends ActiveRecordCommon
  52. {
  53. const TYPE_INITIAL_CREDIT = 'initial-credit';
  54. const TYPE_CREDIT = 'credit';
  55. const TYPE_PAYMENT = 'payment';
  56. const TYPE_REFUND = 'refund';
  57. const TYPE_DEBIT = 'debit';
  58. /**
  59. * @inheritdoc
  60. */
  61. public static function tableName()
  62. {
  63. return 'credit_history';
  64. }
  65. /**
  66. * @inheritdoc
  67. */
  68. public function rules()
  69. {
  70. return [
  71. [['amount'], 'required'],
  72. [['id_user', 'id_user_action', 'id_order', 'id_producer'], 'integer'],
  73. [['date'], 'safe'],
  74. [['amount'], 'double'],
  75. [['type', 'mean_payment', 'comment'], 'string', 'max' => 255],
  76. ];
  77. }
  78. /**
  79. * @inheritdoc
  80. */
  81. public function attributeLabels()
  82. {
  83. return [
  84. 'id' => 'ID',
  85. 'id_user' => 'Utilisateur',
  86. 'id_user_action' => 'Utilisateur',
  87. 'id_order' => 'Commande',
  88. 'date' => 'Date',
  89. 'amount' => 'Montant',
  90. 'type' => 'Type',
  91. 'id_producer' => 'Producteur',
  92. 'mean_payment' => 'Moyen de paiement',
  93. 'comment' => 'Commentaire',
  94. ];
  95. }
  96. /*
  97. * Relations
  98. */
  99. public function getUser()
  100. {
  101. return $this->hasOne(User::className(), ['id' => 'id_user']);
  102. }
  103. public function getUserAction()
  104. {
  105. return $this->hasOne(User::className(), ['id' => 'id_user_action']);
  106. }
  107. public function getOrder()
  108. {
  109. return $this->hasOne(Order::className(), ['id' => 'id_order']);
  110. }
  111. /**
  112. * Retourne les options de base nécessaires à la fonction de recherche.
  113. *
  114. * @return array
  115. */
  116. public static function defaultOptionsSearch() {
  117. return [
  118. 'with' => [],
  119. 'join_with' => [],
  120. 'orderby' => self::tableName().'.date ASc',
  121. 'attribute_id_producer' => self::tableName().'.id_producer'
  122. ] ;
  123. }
  124. /**
  125. * Retourne le type de CreditHistorique (paiement, remboursement ou débit).
  126. *
  127. * @return string
  128. */
  129. public function getStrType()
  130. {
  131. switch ($this->type) {
  132. case self::TYPE_PAYMENT:
  133. return 'Paiement';
  134. break;
  135. case self::TYPE_REFUND:
  136. return 'Remboursement';
  137. break;
  138. case self::TYPE_DEBIT:
  139. return 'Débit';
  140. break;
  141. }
  142. }
  143. /**
  144. * Enregistre le modèle.
  145. *
  146. * @param boolean $runValidation
  147. * @param array $attributeNames
  148. */
  149. public function save($runValidation = true, $attributeNames = NULL)
  150. {
  151. // initialisation du commentaire avant sauvegarde
  152. $this->comment .= $this->getStrComment() ;
  153. parent::save($runValidation, $attributeNames);
  154. // mise à jour du crédit au niveau de UserProducer
  155. $userProducer = UserProducer::searchOne([
  156. 'id_user' => $this->id_user,
  157. 'id_producer' => $this->id_producer
  158. ]) ;
  159. $creditLimitReminder = Producer::getConfig('credit_limit_reminder') ;
  160. $oldCredit = $userProducer->credit ;
  161. if ($userProducer) {
  162. if ($this->isTypeCredit()) {
  163. $userProducer->credit += $this->amount;
  164. } elseif ($this->isTypeDebit()) {
  165. $userProducer->credit -= $this->amount;
  166. }
  167. $userProducer->save();
  168. // set mean payment
  169. if($this->id_order && $this->id_order > 0) {
  170. $order = Order::searchOne(['id' => (int) $this->id_order]) ;
  171. if($order) {
  172. $paymentStatus = $order->getPaymentStatus() ;
  173. if($paymentStatus == Order::PAYMENT_PAID
  174. || $paymentStatus == Order::PAYMENT_SURPLUS) {
  175. $order->mean_payment = MeanPayment::CREDIT ;
  176. $order->save() ;
  177. }
  178. }
  179. }
  180. // seuil limite de crédit
  181. $newCredit = $userProducer->credit ;
  182. if(!is_null($creditLimitReminder) &&
  183. $oldCredit > $creditLimitReminder && $newCredit <= $creditLimitReminder) {
  184. $user = User::findOne($this->id_user) ;
  185. $producer = Producer::findOne($this->id_producer) ;
  186. Yii::$app->mailer->compose(
  187. [
  188. 'html' => 'creditLimitReminder-html',
  189. 'text' => 'creditLimitReminder-text'
  190. ],
  191. [
  192. 'user' => $user,
  193. 'producer' => $producer,
  194. 'credit' => $newCredit
  195. ]
  196. )
  197. ->setTo($user->email)
  198. ->setFrom(['contact@opendistrib.net' => 'distrib'])
  199. ->setSubject('[distrib] Seuil limite de crédit dépassé')
  200. ->send();
  201. }
  202. }
  203. }
  204. /**
  205. * Retourne si le CreditHistorique est un débit ou non.
  206. *
  207. * @return boolean
  208. */
  209. public function isTypeDebit()
  210. {
  211. return in_array($this->type, [
  212. self::TYPE_DEBIT,
  213. self::TYPE_PAYMENT,
  214. ]) ;
  215. }
  216. /**
  217. * Retourne si le CreditHistorique est un crédit ou non.
  218. *
  219. * @return boolean
  220. */
  221. public function isTypeCredit()
  222. {
  223. return in_array($this->type, [
  224. self::TYPE_CREDIT,
  225. self::TYPE_INITIAL_CREDIT,
  226. self::TYPE_REFUND
  227. ]) ;
  228. }
  229. /**
  230. * Retourne le montant.
  231. *
  232. * @param boolean $format
  233. * @return float
  234. */
  235. public function getAmount($format = false)
  236. {
  237. if($format) {
  238. return number_format($this->amount,2) .'&nbsp;€' ;
  239. }
  240. else {
  241. return $this->amount ;
  242. }
  243. }
  244. /**
  245. * Retourne le libellé du CreditHistory informant de son type et
  246. * éventuellement de la date de sa commande associée.
  247. *
  248. * @return string
  249. */
  250. public function getStrWording()
  251. {
  252. $str = '' ;
  253. if($this->type == self::TYPE_INITIAL_CREDIT) {
  254. $str = 'Crédit initial' ;
  255. }
  256. elseif($this->type == self::TYPE_CREDIT) {
  257. $str = 'Crédit' ;
  258. }
  259. elseif($this->type == self::TYPE_PAYMENT) {
  260. $str = 'Paiement' ;
  261. }
  262. elseif($this->type == self::TYPE_REFUND) {
  263. $str = 'Remboursement' ;
  264. }
  265. elseif($this->type == self::TYPE_DEBIT) {
  266. $str = 'Débit' ;
  267. }
  268. if($this->type == self::TYPE_PAYMENT || $this->type == self::TYPE_REFUND) {
  269. if(isset($this->order)) {
  270. $str .= '<br />Commande : '.date('d/m/Y',strtotime($this->order->distribution->date)) ;
  271. }
  272. else {
  273. $str .= '<br />Commande supprimée' ;
  274. }
  275. }
  276. return $str ;
  277. }
  278. /**
  279. * Retourne les informations à ajouter au commentaire du CreditHistorique
  280. * (libellé, montant, client, action) au format HTML.
  281. *
  282. * @return string
  283. */
  284. public function getStrComment()
  285. {
  286. $str = '' ;
  287. if(strlen($this->comment)) {
  288. $str .= '<br />' ;
  289. }
  290. $str .= $this->getStrWording() ;
  291. if(isset($this->order)) {
  292. $str .= '<br />Montant de la commande : '.$this->order->getAmountWithTax(Order::AMOUNT_TOTAL, true) ;
  293. }
  294. if(isset($this->user)) {
  295. $str .= '<br />Client : '.Html::encode($this->user->name. ' '.$this->user->lastname) ;
  296. }
  297. if(isset($this->userAction)) {
  298. $str .= '<br />Action : '.Html::encode($this->userAction->name. ' '.$this->userAction->lastname) ;
  299. }
  300. return $str ;
  301. }
  302. /**
  303. * Retourne la date.
  304. *
  305. * @param boolean $format
  306. * @return string
  307. */
  308. public function getDate($format = false)
  309. {
  310. if($format)
  311. return date('d/m/Y à H:i:s',strtotime($this->date)) ;
  312. else
  313. return $this->date ;
  314. }
  315. /**
  316. * Retourne le libellé du moyen de paiement du CreditHistory courant.
  317. *
  318. * @return string
  319. */
  320. public function getStrMeanPayment()
  321. {
  322. return MeanPayment::getStrBy($this->mean_payment) ;
  323. }
  324. /**
  325. * Retourne le libellé de l'utilisateur ayant initié l'action.
  326. *
  327. * @return string
  328. */
  329. public function strUserAction()
  330. {
  331. if($this->userAction) {
  332. return $this->userAction->name . ' ' . $this->userAction->lastname ;
  333. }
  334. else {
  335. return 'Système' ;
  336. }
  337. }
  338. }