Yarik / artbox-webcomment

  <?php
      

      namespace artbox\webcomment\behaviors;

      use artbox\webcomment\models\CommentModel;
      use artbox\webcomment\models\interfaces\RatingCacheInterface;

      use yii\base\Behavior;
      use yii\base\InvalidConfigException;

      use yii\base\InvalidParamException;

      use yii\db\ActiveQuery;
      use yii\db\ActiveRecord;
      
      /**
       * Class CommentBehavior
       *
       * @property ActiveQuery    $averageRating
       * @property CommentModel[] $comments

       * @package artbox\webcomment\behaviors

       */
      class CommentBehavior extends Behavior
      {
          
          /**
           * Fully-classified name of class to hold rating cache
           *
           * @var string
           */
          private $cacheModelName = '';
          
          /**
           * Class to hold rating cache
           *
           * @var RatingCacheInterface
           */
          private $cacheModel = null;
          
          /**
           * Whether to cache rating or not
           *
           * @var bool
           */
          private $cacheRating = false;

          /**
           * @inheritdoc
           */
          public function attach($owner)
          {
              if ($this->cacheRating) {

                  if (empty($this->cacheModelName) || !is_string($this->cacheModelName)) {

                      throw new InvalidConfigException(
                          'To use rating cache you must set $cacheModelName where to store it'
                      );
                  }
                  $this->setCacheModel(
                      \Yii::createObject(
                          [
                              'class' => $this->cacheModelName,
                          ]
                      )
                  );
              }
              parent::attach($owner);
          }
          
          /**
           * Get fully-classified name of class to hold rating cache
           *
           * @return string
           */

          public function getCacheModelName(): string

          {
              return $this->cacheModelName;
          }
          
          /**
           * Set fully-classified name of class to hold rating cache
           *
           * @param string $value
           */
          public function setCacheModelName(string $value)
          {
              $this->cacheModelName = $value;
          }
          
          /**
           * Get model to hold rating cache

           */

          public function getCacheModel(): RatingCacheInterface

          {
              return $this->cacheModel;
          }
          
          /**
           * Set model to hold cache
           *

           * @param \artbox\webcomment\models\interfaces\RatingCacheInterface|null $value

           */
          private function setCacheModel(RatingCacheInterface $value = null)
          {
              $this->cacheModel = $value;
          }
          
          /**
           * Whether cache rating or not
           *
           * @return bool
           */
          public function getCacheRating(): bool
          {
              return $this->cacheRating;
          }
          
          /**
           * Set whether to cache rating or not
           *
           * @param bool $value
           */
          public function setCacheRating(bool $value)
          {
              $this->cacheRating = $value;
          }
          
          /**
           * Get query to get all comments for current $owner model
           *
           * @return \yii\db\ActiveQuery
           */
          public function getComments(): ActiveQuery
          {
              /**
               * @var ActiveRecord $owner
               */
              $owner = $this->owner;

              $pkKeys = $owner->primaryKey();
              if (!empty($pkKeys)) {
                  $pkKey = $pkKeys[ 0 ];
              } else {
                  throw new InvalidParamException('Entity must have primary key.');
              }
              $pk = $owner->getAttribute($pkKey);

              $query = $owner->hasMany(CommentModel::className(), [ 'entity_id' => $pk ])
                             ->where(
                                 [

                                     'artbox_comment.entity'    => $owner::className(),
                                     'artbox_comment.status'    => CommentModel::STATUS_ACTIVE,
                                     'artbox_comment.parent_id' => null,

                                 ]
                             );
              return $query;
          }
          
          /**
           * Get query to get average rating for current $owner model if it cached
           *
           * @return \yii\db\ActiveQuery
           */
          public function getAverageRating(): ActiveQuery
          {
              /**
               * @var ActiveRecord $owner
               */
              $owner = $this->owner;
              $pk = $owner->primaryKey()[ 0 ];
              $query = $owner->hasOne($this->cacheModelName, [ $this->cacheModel->getLinkAttribute() => $pk ]);
              return $query;
          }
          
          /**
           * Recalculate cache for current $owner model
           *
           * @return bool
           */
          public function recalculateRating(): bool
          {
              /**
               * @var RatingCacheInterface $averageRating
               */
              $average = $this->getComments()
                              ->joinWith('rating')
                              ->select([ 'average' => 'avg(artbox_comment_rating.value)::float' ])
                              ->scalar();
              if (!$average) {
                  $average = 0;
              }
              $averageRating = $this->getAverageRating()
                                    ->one();

              if (!empty($averageRating)) {

                  $averageRating->setValue($average);
              } else {
                  /**
                   * @var ActiveRecord         $owner
                   * @var RatingCacheInterface $averageRating
                   */
                  $owner = $this->owner;
                  $pk = $owner->primaryKey()[ 0 ];
                  $averageRating = \Yii::createObject(
                      [
                          'class'                               => $this->cacheModelName,
                          $this->cacheModel->getLinkAttribute() => $this->owner->$pk,
                      ]
                  );
                  $averageRating->setValue($average);
              }
              if ($averageRating->save()) {
                  return true;
              } else {
                  return false;
              }
          }
      }