Review.php

Go to the documentation of this file.

<?php
namespace Magento\Review\Model\ResourceModel;

use Magento\Framework\Model\AbstractModel;

class Review extends \Magento\Framework\Model\ResourceModel\Db\AbstractDb
{
    protected $_reviewTable;

    protected $_reviewDetailTable;

    protected $_reviewStatusTable;

    protected $_reviewEntityTable;

    protected $_reviewStoreTable;

    protected $_aggregateTable;

    private $_deleteCache = [];

    protected $_date;

    protected $_storeManager;

    protected $_ratingFactory;

    protected $_ratingOptions;

    public function __construct(
        \Magento\Framework\Model\ResourceModel\Db\Context $context,
        \Magento\Framework\Stdlib\DateTime\DateTime $date,
        \Magento\Store\Model\StoreManagerInterface $storeManager,
        \Magento\Review\Model\RatingFactory $ratingFactory,
        Rating\Option $ratingOptions,
        $connectionName = null
    ) {
        $this->_date = $date;
        $this->_storeManager = $storeManager;
        $this->_ratingFactory = $ratingFactory;
        $this->_ratingOptions = $ratingOptions;

        parent::__construct($context, $connectionName);
    }

    protected function _construct()
    {
        $this->_init('review', 'review_id');
        $this->_reviewTable = $this->getTable('review');
        $this->_reviewDetailTable = $this->getTable('review_detail');
        $this->_reviewStatusTable = $this->getTable('review_status');
        $this->_reviewEntityTable = $this->getTable('review_entity');
        $this->_reviewStoreTable = $this->getTable('review_store');
        $this->_aggregateTable = $this->getTable('review_entity_summary');
    }

    protected function _getLoadSelect($field, $value, $object)
    {
        $select = parent::_getLoadSelect($field, $value, $object);
        $select->join(
            $this->_reviewDetailTable,
            $this->getMainTable() . ".review_id = {$this->_reviewDetailTable}.review_id"
        );
        return $select;
    }

    protected function _beforeSave(AbstractModel $object)
    {
        if (!$object->getId()) {
            $object->setCreatedAt($this->_date->gmtDate());
        }
        if ($object->hasData('stores') && is_array($object->getStores())) {
            $stores = $object->getStores();
            $stores[] = 0;
            $object->setStores($stores);
        } elseif ($object->hasData('stores')) {
            $object->setStores([$object->getStores(), 0]);
        }
        return $this;
    }

    protected function _afterSave(AbstractModel $object)
    {
        $connection = $this->getConnection();
        $detail = [
            'title' => $object->getTitle(),
            'detail' => $object->getDetail(),
            'nickname' => $object->getNickname(),
        ];
        $select = $connection->select()->from($this->_reviewDetailTable, 'detail_id')->where('review_id = :review_id');
        $detailId = $connection->fetchOne($select, [':review_id' => $object->getId()]);

        if ($detailId) {
            $condition = ["detail_id = ?" => $detailId];
            $connection->update($this->_reviewDetailTable, $detail, $condition);
        } else {
            $detail['store_id'] = $object->getStoreId();
            $detail['customer_id'] = $object->getCustomerId();
            $detail['review_id'] = $object->getId();
            $connection->insert($this->_reviewDetailTable, $detail);
        }

        $stores = $object->getStores();
        if (!empty($stores)) {
            $condition = ['review_id = ?' => $object->getId()];
            $connection->delete($this->_reviewStoreTable, $condition);

            $insertedStoreIds = [];
            foreach ($stores as $storeId) {
                if (in_array($storeId, $insertedStoreIds)) {
                    continue;
                }

                $insertedStoreIds[] = $storeId;
                $storeInsert = ['store_id' => $storeId, 'review_id' => $object->getId()];
                $connection->insert($this->_reviewStoreTable, $storeInsert);
            }
        }

        // reaggregate ratings, that depend on this review
        $this->_aggregateRatings($this->_loadVotedRatingIds($object->getId()), $object->getEntityPkValue());

        return $this;
    }

    protected function _afterLoad(AbstractModel $object)
    {
        $connection = $this->getConnection();
        $select = $connection->select()->from(
            $this->_reviewStoreTable,
            ['store_id']
        )->where(
            'review_id = :review_id'
        );
        $stores = $connection->fetchCol($select, [':review_id' => $object->getId()]);
        if (empty($stores) && $this->_storeManager->hasSingleStore()) {
            $object->setStores([$this->_storeManager->getStore(true)->getId()]);
        } else {
            $object->setStores($stores);
        }
        return $this;
    }

    protected function _beforeDelete(AbstractModel $object)
    {
        // prepare rating ids, that depend on review
        $this->_deleteCache = [
            'ratingIds' => $this->_loadVotedRatingIds($object->getId()),
            'entityPkValue' => $object->getEntityPkValue(),
        ];
        return $this;
    }

    public function afterDeleteCommit(AbstractModel $object)
    {
        $this->aggregate($object);

        // reaggregate ratings, that depended on this review
        $this->_aggregateRatings($this->_deleteCache['ratingIds'], $this->_deleteCache['entityPkValue']);
        $this->_deleteCache = [];

        return $this;
    }

    public function getTotalReviews($entityPkValue, $approvedOnly = false, $storeId = 0)
    {
        $connection = $this->getConnection();
        $select = $connection->select()->from(
            $this->_reviewTable,
            ['review_count' => new \Zend_Db_Expr('COUNT(*)')]
        )->where(
            "{$this->_reviewTable}.entity_pk_value = :pk_value"
        );
        $bind = [':pk_value' => $entityPkValue];
        if ($storeId > 0) {
            $select->join(
                ['store' => $this->_reviewStoreTable],
                $this->_reviewTable . '.review_id=store.review_id AND store.store_id = :store_id',
                []
            );
            $bind[':store_id'] = (int) $storeId;
        }
        if ($approvedOnly) {
            $select->where("{$this->_reviewTable}.status_id = :status_id");
            $bind[':status_id'] = \Magento\Review\Model\Review::STATUS_APPROVED;
        }
        return $connection->fetchOne($select, $bind);
    }

    public function aggregate($object)
    {
        if (!$object->getEntityPkValue() && $object->getId()) {
            $object->load($object->getReviewId());
        }

        $ratingModel = $this->_ratingFactory->create();
        $ratingSummaries = $ratingModel->getEntitySummary($object->getEntityPkValue(), false);

        foreach ($ratingSummaries as $ratingSummaryObject) {
            $this->aggregateReviewSummary($object, $ratingSummaryObject);
        }
    }

    protected function aggregateReviewSummary($object, $ratingSummaryObject)
    {
        $connection = $this->getConnection();

        if ($ratingSummaryObject->getCount()) {
            $ratingSummary = round($ratingSummaryObject->getSum() / $ratingSummaryObject->getCount());
        } else {
            $ratingSummary = $ratingSummaryObject->getSum();
        }

        $reviewsCount = $this->getTotalReviews(
            $object->getEntityPkValue(),
            true,
            $ratingSummaryObject->getStoreId()
        );
        $select = $connection->select()->from($this->_aggregateTable)
            ->where('entity_pk_value = :pk_value')
            ->where('entity_type = :entity_type')
            ->where('store_id = :store_id');
        $bind = [
            ':pk_value' => $object->getEntityPkValue(),
            ':entity_type' => $object->getEntityId(),
            ':store_id' => $ratingSummaryObject->getStoreId(),
        ];
        $oldData = $connection->fetchRow($select, $bind);
        $data = new \Magento\Framework\DataObject();

        $data->setReviewsCount($reviewsCount)
            ->setEntityPkValue($object->getEntityPkValue())
            ->setEntityType($object->getEntityId())
            ->setRatingSummary($ratingSummary > 0 ? $ratingSummary : 0)
            ->setStoreId($ratingSummaryObject->getStoreId());

        $this->writeReviewSummary($oldData, $data);
    }

    protected function writeReviewSummary($oldData, \Magento\Framework\DataObject $data)
    {
        $connection = $this->getConnection();
        $connection->beginTransaction();
        try {
            if (isset($oldData['primary_id']) && $oldData['primary_id'] > 0) {
                $condition = ["{$this->_aggregateTable}.primary_id = ?" => $oldData['primary_id']];
                $connection->update($this->_aggregateTable, $data->getData(), $condition);
            } else {
                $connection->insert($this->_aggregateTable, $data->getData());
            }
            $connection->commit();
        } catch (\Exception $e) {
            $connection->rollBack();
        }
    }

    protected function _loadVotedRatingIds($reviewId)
    {
        $connection = $this->getConnection();
        if (empty($reviewId)) {
            return [];
        }
        $select = $connection->select()->from(['v' => $this->getTable('rating_option_vote')], 'r.rating_id')
            ->joinInner(['r' => $this->getTable('rating')], 'v.rating_id=r.rating_id')
            ->where('v.review_id = :revire_id');
        return $connection->fetchCol($select, [':revire_id' => $reviewId]);
    }

    protected function _aggregateRatings($ratingIds, $entityPkValue)
    {
        if ($ratingIds && !is_array($ratingIds)) {
            $ratingIds = [(int)$ratingIds];
        }
        if ($ratingIds && $entityPkValue) {
            foreach ($ratingIds as $ratingId) {
                $this->_ratingOptions->aggregateEntityByRatingId($ratingId, $entityPkValue);
            }
        }
        return $this;
    }

    public function reAggregateReview($reviewId, $entityPkValue)
    {
        $this->_aggregateRatings($this->_loadVotedRatingIds($reviewId), $entityPkValue);
    }

    public function getEntityIdByCode($entityCode)
    {
        $connection = $this->getConnection();
        $select = $connection->select()->from($this->_reviewEntityTable, ['entity_id'])
            ->where('entity_code = :entity_code');
        return $connection->fetchOne($select, [':entity_code' => $entityCode]);
    }

    public function deleteReviewsByProductId($productId)
    {
        $this->getConnection()->delete(
            $this->_reviewTable,
            [
                'entity_pk_value=?' => $productId,
                'entity_id=?' => $this->getEntityIdByCode(\Magento\Review\Model\Review::ENTITY_PRODUCT_CODE)
            ]
        );
        $this->getConnection()->delete(
            $this->getTable('review_entity_summary'),
            [
                'entity_pk_value=?' => $productId,
                'entity_type=?' => $this->getEntityIdByCode(\Magento\Review\Model\Review::ENTITY_PRODUCT_CODE)
            ]
        );
        return $this;
    }
}