HOME

Mini Shell 1.0
DIR:/home/htlwork.com/www/dev/pricelow/app/code/Blog/Model/ResourceModel/
Current File : /home/htlwork.com/www/dev/pricelow/app/code/Blog/Model/ResourceModel/Post.php
<?php
/**
 * Landofcoder
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Landofcoder.com license that is
 * available through the world-wide-web at this URL:
 * https://landofcoder.com/license-agreement.html
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade this extension to newer
 * version in the future.
 *
 * @category   Landofcoder
 * @package    Lofmp_Blog
 * @copyright  Copyright (c) 2016 Landofcoder (https://landofcoder.com/)
 * @license    https://landofcoder.com/LICENSE-1.0.html
 */
namespace Lofmp\Blog\Model\ResourceModel;

use Lofmp\Blog\Model\Category;
use Lofmp\Blog\Model\Tag;

class Post extends \Magento\Framework\Model\ResourceModel\Db\AbstractDb
{
    /**
     * Store manager
     *
     * @var \Magento\Store\Model\StoreManagerInterface
     */
    protected $_storeManager;

    /**
     * @var \Magento\Framework\Stdlib\DateTime\DateTime
     */
    protected $_date;

    /**
     * @var mixed|array
     */
    protected $_categories = [];

    /**
     * Construct
     *
     * @param \Magento\Framework\Model\ResourceModel\Db\Context $context
     * @param \Magento\Store\Model\StoreManagerInterface $storeManager
     * @param \Magento\Framework\Stdlib\DateTime\DateTime $date
     * @param null $connectionName
     */
    public function __construct(
        \Magento\Framework\Model\ResourceModel\Db\Context $context,
        \Magento\Store\Model\StoreManagerInterface $storeManager,
        \Magento\Framework\Stdlib\DateTime\DateTime $date,
        $connectionName = null
        ) {
        parent::__construct($context, $connectionName);
        $this->_storeManager = $storeManager;
        $this->_date = $date;
    }

    /**
     * Initialize resource model
     *
     * @return void
     */
    protected function _construct()
    {
        $this->_init('lofmp_blog_post', 'post_id');
    }

    /**
     * Process block data before deleting
     *
     * @param \Magento\Framework\Model\AbstractModel $object
     * @return \Magento\Cms\Model\ResourceModel\Page
     */
    protected function _beforeDelete(\Magento\Framework\Model\AbstractModel $object)
    {
        $condition = ['post_id = ?' => (int)$object->getId()];

        $this->getConnection()->delete($this->getTable('lofmp_blog_post_store'), $condition);

        $this->getConnection()->delete($this->getTable('lofmp_blog_post_tag'), $condition);

        return parent::_beforeDelete($object);
    }

    /**
     * Perform operations before object save
     *
     * @param \Magento\Framework\Model\AbstractModel $object
     * @return $this
     * @throws \Magento\Framework\Exception\LocalizedException
     */
    protected function _beforeSave(\Magento\Framework\Model\AbstractModel $object)
    {
        $identifierGenerator = \Magento\Framework\App\ObjectManager::getInstance()
                ->create(\Lofmp\Blog\Model\ResourceModel\PageIdentifierGenerator::class);
        $identifierGenerator->generate($object);

        if (!$this->getIsUniqueBlockToStores($object) && !$object->getData('importing')) {
            throw new \Magento\Framework\Exception\LocalizedException(
                __('A post identifier with the same properties already exists in the selected store.')
                );
        }
        if($object->getData('importing') && !$this->getIsUniqueBlockToStores($object) && !$object->getData('overwrite')) {
            $data = $object->getData();
            $data['identifier'] = $data['identifier'] . time();
            $object->setData($data);
        }
        return $this;
    }

    /**
     * Perform operations after object save
     *
     * @param \Magento\Framework\Model\AbstractModel $object
     * @return $this
     */
    protected function _afterSave(\Magento\Framework\Model\AbstractModel $object)
    {
        if (!$object->getData("isfrontend")) {
            $postData = $object->getData();

            // STORE
            if(isset($postData['stores'])) {
                $stores = $object->getStores();
                $table = $this->getTable('lofmp_blog_post_store');
                $where = ['post_id = ?' => (int)$object->getId()];
                $this->getConnection()->delete($table, $where);
                if (!empty($stores)) {
                    $data = [];
                    foreach ($stores as $storeId) {
                        $data[] = [
                            'post_id'  => (int)$object->getId(),
                            'store_id' => (int)$storeId
                        ];
                    }
                    try {
                        $this->getConnection()->insertMultiple($table, $data);
                    } catch(\Exception $e) {
                        throw new \Exception($e->getMessage());
                    }
                }
            }

            // Categories
            if (isset($postData['category_ids'])) {
                $newCategories = (array)$postData['category_ids'];
                $table = $this->getTable('lofmp_blog_post_category');
                $where = ['post_id = ?' => (int)$object->getId()];
                $this->getConnection()->delete($table, $where);
                $data = [];

                if (!empty($newCategories)) {
                    foreach ($newCategories as $cat) {
                        $catId = isset($cat['category_id'])?$cat['category_id']:$cat;
                        if ($catId) {
                            $data[] = [
                                'post_id'     => (int)$object->getId(),
                                'category_id' => (int)$catId,
                                'position'    => (int)$object->getPosition()
                            ];
                        }
                    }
                    try {
                        if ($data) {
                            $this->getConnection()->insertMultiple($table, $data);
                        }
                    } catch(\Exception $e) {
                        throw new \Exception($e->getMessage());
                    }
                }
            }

            /* Save category & tag links */
            foreach (['tag' => 'tags'] as $linkType => $dataKey) {
                $newIds = (array)$object->getData($dataKey);
                foreach ($newIds as $key => $id) {
                    if (!$id) { // e.g.: zero
                        unset($newIds[$key]);
                    }
                }
                if (is_array($newIds)) {
                    $lookup = 'lookup' . ucfirst($linkType) . 'Ids';
                    $oldIds = $this->$lookup($object->getId());
                    $this->_updateLinks(
                        $object,
                        $newIds,
                        $oldIds,
                        'lofmp_blog_post_' . $linkType,
                        'related_id'
                    );
                }
            }

            /* Save related post & product links */
            if ($links = $object->getData('links')) {
                if (is_array($links)) {
                    foreach (['post', 'product'] as $linkType) {
                        if (isset($links[$linkType]) && is_array($links[$linkType])) {
                            $linksData = $links[$linkType];
                            $lookup = 'lookupRelated' . ucfirst($linkType) . 'Ids';
                            $oldIds = $this->$lookup($object->getId());

                            switch ($linkType) {
                                case "post":
                                    $linkRelatedType = "_related";
                                    $relatedId = "related_id";
                                break;
                                case "product":
                                default:
                                    $linkRelatedType = "_products_related";
                                    $relatedId = "entity_id";
                                break;
                            }

                            $this->_updateLinks(
                                $object,
                                array_keys($linksData),
                                $oldIds,
                                'lofmp_blog_post' . $linkRelatedType,
                                $relatedId,
                                $linksData
                            );
                        }
                    }
                }
            } else {
                // Posts Related
                if (isset($postData['posts_related'])) {
                    $postsRelated = $postData['posts_related'];
                    $table = $this->getTable('lofmp_blog_post_related');
                    $where = ['post_id = ?' => (int)$object->getId()];
                    $this->getConnection()->delete($table, $where);
                    $data = [];
                    if(!empty($postsRelated)){
                        foreach ($postsRelated as $k => $_post) {
                            $postId = isset($_post["post_id"]) ? $_post["post_id"] : $k;
                            if ($postId) {
                                $data[] = [
                                    'post_id'         => (int)$object->getId(),
                                    'related_id' => $postId,
                                    'position'        => $_post['position']
                                ];
                            }
                        }
                        try {
                            if ($data) {
                                $this->getConnection()->insertMultiple($table, $data);
                            }
                        } catch(\Exception $e) {
                            throw new \Exception($e->getMessage());
                        }
                    }
                }

                // Products Related
                if (isset($postData['products_related'])) {
                    $productsRelated = $postData['products_related'];
                    $table = $this->getTable('lofmp_blog_post_products_related');
                    $where = ['post_id = ?' => (int)$object->getId()];
                    $this->getConnection()->delete($table, $where);
                    $data = [];
                    if(!empty($productsRelated)){
                        foreach ($productsRelated as $k => $_post) {
                            $entityId = isset($_post["entity_id"]) ? $_post["entity_id"] : $k;
                            if ($entityId) {
                                $data[] = [
                                    'post_id'   => (int)$object->getId(),
                                    'entity_id' => $entityId,
                                    'position'  => $_post['position']
                                ];
                            }
                        }
                        try {
                            if ($data) {
                                $this->getConnection()->insertMultiple($table, $data);
                            }
                        } catch(\Exception $e) {
                            throw new \Exception($e->getMessage());
                        }
                    }
                }
            }
        }
        return parent::_afterSave($object);
    }

    /**
     * Update post connections
     * @param  \Magento\Framework\Model\AbstractModel $object
     * @param  Array $newRelatedIds
     * @param  Array $oldRelatedIds
     * @param  String $tableName
     * @param  String  $field
     * @param  Array  $rowData
     * @return void
     */
    protected function _updateLinks(
        \Magento\Framework\Model\AbstractModel $object,
        array $newRelatedIds,
        array $oldRelatedIds,
        $tableName,
        $field,
        $rowData = []
    ) {
        $table = $this->getTable($tableName);

        if ($object->getId() && empty($rowData)) {
            $currentData = $this->_lookupAll($object->getId(), $tableName, '*');
            foreach ($currentData as $item) {
                $rowData[$item[$field]] = $item;
            }
        }

        $insert = $newRelatedIds;
        $delete = $oldRelatedIds;

        if ($delete) {
            $where = ['post_id = ?' => (int)$object->getId(), $field.' IN (?)' => $delete];

            $this->getConnection()->delete($table, $where);
        }

        if ($insert) {
            $data = [];

            foreach ($insert as $id) {
                $id = (int)$id;
                $data[] = array_merge(
                    ['post_id' => (int)$object->getId(), $field => $id],
                    (isset($rowData[$id]) && is_array($rowData[$id])) ? $rowData[$id] : []
                );
            }

            /* Fix if some rows have extra data */
            $allFields = [];
            foreach ($data as $i => $row) {
                foreach ($row as $key => $value) {
                    $allFields[$key] = $key;
                }
            }
            foreach ($data as $i => $row) {
                foreach ($allFields as $key) {
                    if (!array_key_exists($key, $row)) {
                        $data[$i][$key] = null;
                    }
                }
            }
            /* End fix */

            $this->getConnection()->insertMultiple($table, $data);
        }
    }

    /**
     * Get rows to which specified item is assigned
     * @param  int $postId
     * @param  string $tableName
     * @param  string $field
     * @return array
     */
    protected function _lookupAll($postId, $tableName, $field)
    {
        $adapter = $this->getConnection();

        $select = $adapter->select()->from(
            $this->getTable($tableName),
            $field
        )->where(
            'post_id = ?',
            (int)$postId
        );

        return $adapter->fetchAll($select);
    }

    /**
     * Load an object using 'identifier' field if there's no field specified and value is not numeric
     *
     * @param \Magento\Framework\Model\AbstractModel $object
     * @param mixed $value
     * @param string $field
     * @return $this
     */
    public function load(\Magento\Framework\Model\AbstractModel $object, $value, $field = null)
    {
        if (!is_numeric($value) && $field === null) {
            $field = 'identifier';
        }

        return parent::load($object, $value, $field);
    }

    /**
     * Perform operations after object load
     *
     * @param \Magento\Framework\Model\AbstractModel $object
     * @return $this
     */
    protected function _afterLoad(\Magento\Framework\Model\AbstractModel $object)
    {
        if ($id = $object->getId()) {
            $stores = $this->lookupStoreIds($object->getId());
            $categoryIds = $this->lookupCategoryIds($object->getId());
            $categories = $this->getPostCategories($object->getId());

            $connection = $this->getConnection();
            $select = $connection->select()->from($this->getTable('lofmp_blog_comment'))
                ->where('post_id = ' . $object->getId())
                ->where('is_active = 1');
            $comments = $connection->fetchAll($select);

            /** get related posts */
            $connection = $this->getConnection();
            $select = $connection->select()
                ->from($this->getTable('lofmp_blog_post_related'), 'related_id')
                ->where(
                    'post_id = '.(int)$id
                )
                ->order('position ASC');
            $postsRelated = $connection->fetchAll($select);

            /** get related producs */
            $connection = $this->getConnection();
            $select = $connection->select()
                ->from($this->getTable('lofmp_blog_post_products_related'), "entity_id")
                ->where(
                    'post_id = '.(int)$id
                )
                ->order('position ASC');

            $products = $connection->fetchAll($select);

            $object->setData('store_id', $stores);
            $object->setData('stores', $stores);
            $object->setData('category_id', $categoryIds);
            //$object->setData('categories', $categories);
            $object->setData("comments", $comments);
            $object->setData('posts_related', $postsRelated);
            $object->setData('related_products', $products);
            $object->setCategories($categories);
            $object->setCategoryIds($categoryIds);

            $tags = $this->lookupTagIds($object->getId());
            $object->setTags($tags);
        }
        return parent::_afterLoad($object);
    }

    /**
     * Get tag ids to which specified item is assigned
     *
     * @param int $postId
     * @return array
     */
    public function lookupTagIds($postId)
    {
        return $this->_lookupIds($postId, 'lofmp_blog_post_tag', 'related_id');
    }

    /**
     * Get related post ids to which specified item is assigned
     *
     * @param int $postId
     * @return array
     */
    public function lookupRelatedPostIds($postId)
    {
        return $this->_lookupIds($postId, 'lofmp_blog_post_related', 'related_id');
    }

    /**
     * Get related product ids to which specified item is assigned
     *
     * @param int $postId
     * @return array
     */
    public function lookupRelatedProductIds($postId)
    {
        return $this->_lookupIds($postId, 'lofmp_blog_post_products_related', 'entity_id');
    }

    /**
     * Get ids to which specified item is assigned
     * @param  int $postId
     * @param  string $tableName
     * @param  string $field
     * @return array
     */
    protected function _lookupIds($postId, $tableName, $field)
    {
        $adapter = $this->getConnection();
        $select = $adapter->select()->from(
            $this->getTable($tableName),
            $field
        )->where(
            'post_id = ?',
            (int)$postId
        );

        return $adapter->fetchCol($select);
    }

    /**
     * Get ids to which specified item is assigned
     * @param  int $postId
     * @param  string $tableName
     * @param  string|string[] $field
     * @return array
     */
    protected function _lookupRows($postId, $tableName, $field)
    {
        $adapter = $this->getConnection();
        $select = $adapter->select()->from(
            $this->getTable($tableName),
            $field
        )->where(
            'post_id = ?',
            (int)$postId
        );

        return $adapter->fetchAll($select);
    }

    /**
     * Retrieve select object for load object data
     *
     * @param string $field
     * @param mixed $value
     * @param \Magento\Cms\Model\Block $object
     * @return \Magento\Framework\DB\Select
     */
    protected function _getLoadSelect($field, $value, $object)
    {
        $select = parent::_getLoadSelect($field, $value, $object);

        if ($object->getStoreId()) {
            $stores = [(int)$object->getStoreId(), \Magento\Store\Model\Store::DEFAULT_STORE_ID];

            $select->join(
                ['cps' => $this->getTable('lofmp_blog_post_store')],
                $this->getMainTable() . '.post_id = cps.post_id',
                ['store_id']
                )->where(
                'is_active = ?',
                1
                )->where(
                'cps.store_id in (?)',
                $stores
                )->order(
                'store_id DESC'
                )->limit(
                1
                );
        }

        return $select;
    }

    /**
     * Check for unique of identifier of block to selected store(s).
     *
     * @param \Magento\Framework\Model\AbstractModel $object
     * @return bool
     * @SuppressWarnings(PHPMD.BooleanGetMethodName)
     */
    public function getIsUniqueBlockToStores(\Magento\Framework\Model\AbstractModel $object)
    {
        if ($this->_storeManager->hasSingleStore()) {
            $stores = [\Magento\Store\Model\Store::DEFAULT_STORE_ID];
        } else {
            $stores = (array)$object->getData('stores');
        }

        $select = $this->getConnection()->select()->from(
            ['cp' => $this->getMainTable()]
            )->join(
                ['cps' => $this->getTable('lofmp_blog_post_store')],
                'cp.post_id = cps.post_id',
                []
            )->where(
                'cp.identifier = ?',
                $object->getData('identifier')
            )->where(
                'cps.store_id IN (?)',
                $stores
            );
        if ($object->getData("seller_id")) {
            $select = $select->where(
                'cp.seller_id = ?',
                $object->getData("seller_id")
            );
        }

        if ($object->getId()) {
            $select->where('cp.post_id <> ?', $object->getId());
        }

        if ($this->getConnection()->fetchRow($select)) {
            return false;
        }

        return true;
    }

    /**
     * Get store ids to which specified item is assigned
     *
     * @param int $id
     * @return array
     */
    public function lookupStoreIds($id)
    {
        $connection = $this->getConnection();

        $select = $connection->select()->from(
            $this->getTable('lofmp_blog_post_store'),
            'store_id'
            )->where(
            'post_id = :post_id'
            );

        $binds = [':post_id' => (int)$id];

        return $connection->fetchCol($select, $binds);
    }

    /**
     * Get store ids to which specified item is assigned
     *
     * @param int $id
     * @return array
     */
    public function lookupPostsRelatedIds($id)
    {
        $connection = $this->getConnection();

        $select = $connection->select()->from(
            $this->getTable('lofmp_blog_post_related'),
            'related_id'
            );

        $binds = [':post_id' => (int)$id];

        return $connection->fetchCol($select, $binds);
    }

    /**
     * Get store ids to which specified item is assigned
     *
     * @param int $id
     * @return mixed|array
     */
    public function lookupCategoryIds($id)
    {
        $catIds = [];
        $categories = $this->getPostCategories($id, false);
        if ($categories) {
            foreach ($categories as $_cat) {
                if (!in_array($_cat["category_id"], $catIds)) {
                    $catIds[] = $_cat["category_id"];
                }
            }
        }
        return $catIds;
    }

    /**
     * Get post tags
     *
     * @param int $post_id
     * @return mixed|array
     */
    public function getPostTags($post_id)
    {
        $select = $this->getConnection()->select()
            ->from(
                ['tag' => $this->getTable('lofmp_blog_tag')]
            )
            ->join(
                ['post_tag' => $this->getTable('lofmp_blog_post_tag')],
                'tag.tag_id = post_tag.related_id',
                []
            )->where('post_tag.post_id = ?', (int)$post_id)
            ->where('tag.is_active = ?', Tag::STATUS_ENABLED);

        return $this->getConnection()->fetchAll($select);
    }

    /**
     * Get post categories
     *
     * @param int $post_id
     * @param bool $filter_approved
     * @return mixed|array
     */
    public function getPostCategories($post_id, $filter_approved = true)
    {
        if (!isset($this->_categories[$post_id])) {
            $select = $this->getConnection()->select()->from(
                    ['cat' => $this->getTable('lofmp_blog_category')]
                )->join(
                    ['cpc' => $this->getTable('lofmp_blog_post_category')],
                    'cat.category_id = cpc.category_id',
                    []
                )->where(
                    'cpc.post_id = ?',
                    (int)$post_id
                )->where(
                    'cat.is_active = ?', Category::STATUS_ENABLED
                )->order('cat.cat_position DESC')
                ->group('cat.category_id');

            if ($filter_approved) {
                $select->where(
                    'cat.is_approved = ?', Category::STATUS_APPROVED
                );
            }
            $this->_categories[$post_id] = $this->getConnection()->fetchAll($select);
        }
        return $this->_categories[$post_id];
    }

    /**
     * Get product ids to which specified item is assigned
     *
     * @param int $id
     * @return mixed|array
     */
    public function getProductsLink($id)
    {
        if ($id) {
            $connection = $this->getConnection();
            $select = $connection->select()
            ->from($this->getTable('lofmp_blog_post_products_related'))
            ->where(
                'post_id = '.(int)$id
            )
            ->order('position ASC');

            return $connection->fetchAll($select);
        }
        return [];
    }

    /**
     * Get product ids to which specified item is assigned
     *
     * @param int $id
     * @return mixed|array
     */
    public function getPostsLink($id)
    {
        if ($id) {
            $connection = $this->getConnection();
            $select = $connection->select()
            ->from($this->getTable('lofmp_blog_post_related'))
            ->where(
                'post_id = '.(int)$id
            )
            ->order('position ASC');
            return $connection->fetchAll($select);
        }
        return [];
    }

        /**
     * convert alias
     *
     * @param string $name
     * @return string
     */
    public function convertAlias($name)
    {
        // Replaces all spaces with hyphens.
        $string = str_replace(' ', '-', $name);
        // Removes special chars.
        $string = preg_replace('/[^A-Za-z0-9\-]/', '', $string);
        // Replaces multiple hyphens with single one.
        $string = preg_replace('/-+/', '-', $string);

        return $string;
    }

    /**
     * Get date
     *
     * @var \Magento\Framework\Stdlib\DateTime\DateTime
     */
    public function getDate()
    {
        return $this->_date;
    }

    /**
     * Check if post identifier exist for specific store
     * return post id if post exists
     *
     * @param string $identifier
     * @param int|array $storeId
     * @param int|null $sellerId
     * @return int
     */
    public function checkIdentifier($identifier, $storeIds, $sellerId = null)
    {
        if (!is_array($storeIds)) {
            $storeIds = [$storeIds];
        }
        $storeIds[] = \Magento\Store\Model\Store::DEFAULT_STORE_ID;
        $select = $this->_getLoadByIdentifierSelect($identifier, $storeIds, $sellerId);
        $select->reset(\Zend_Db_Select::COLUMNS)->columns('cp.post_id')->order('cps.store_id DESC')->limit(1);

        return $this->getConnection()->fetchOne($select);
    }

    /**
     * Check if post identifier exist for specific store
     * return post id if post exists
     *
     * @param string $identifier
     * @param int $storeId
     * @param int|null $sellerId
     * @return \Magento\Framework\DB\Select
     */
    protected function _getLoadByIdentifierSelect($identifier, $storeIds, $sellerId = null)
    {
        $select = $this->getConnection()->select()->from(
            ['cp' => $this->getMainTable()]
        )->join(
            ['cps' => $this->getTable('lofmp_blog_post_store')],
            'cp.post_id = cps.post_id',
            []
        )->where(
            'cp.identifier = ?',
            $identifier
        )->where(
            'cps.store_id IN (?)',
            $storeIds
        );
        if ($sellerId) {
            $select = $select->where(
                'cp.seller_id = ?',
                $sellerId
            );
        }

        return $select;
    }
}