0byt3m1n1-V2

Path: /home/dev2.destoffenstraat.com/app/Firebear/ImportExport/Traits/Export/ [ Home ]
File: Entity.php
<?php
declare(strict_types=1);
/**
 * @copyright: Copyright © 2017 Firebear Studio. All rights reserved.
 * @author   : Firebear Studio <fbeardev@gmail.com>
 */

namespace Firebear\ImportExport\Traits\Export;

use DateTime;
use Exception;
use Firebear\ImportExport\Traits\General as GeneralTrait;
use Magento\Eav\Model\Entity\Collection\AbstractCollection;
use Magento\Store\Model\Store;
use Magento\Framework\Data\Collection\AbstractDb;
use Magento\Framework\Exception\LocalizedException;
use Magento\ImportExport\Model\Export;
use Magento\Eav\Model\Entity\Attribute;

/**
 * Trait Entity
 *
 * @package Firebear\ImportExport\Traits\Export
 */
trait Entity
{
    use GeneralTrait;

    /**
     * @var int
     */
    protected $lastEntityId;

    /**
     * @param array $data
     * @param string|null $entityFieldID
     * @return array
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     */
    public function changeData($data, $entityFieldID = null)
    {
        $listCodes = $this->_parameters['list'];
        if ($entityFieldID) {
            $listCodes[] = $entityFieldID;
        }
        $replaces = $this->_parameters['replace_code'];
        $replacesValues = $this->_parameters['replace_value'];
        $newData = [];
        $allFields = $this->_parameters['all_fields'];
        foreach ($data as $record) {
            $newRecord = [];
            foreach ($record as $code => $value) {
                if (isset($this->_fieldsMap)) {
                    $code = $this->getKeyFromList($this->_fieldsMap, $code) ?: $code;
                }
                if (in_array($code, $listCodes)) {
                    $keyCode = $this->getKeyFromList($listCodes, $code);
                    $newCode = $code;
                    if (is_numeric($keyCode) && isset($replaces[$keyCode])) {
                        $newCode = $replaces[$keyCode];
                    }
                    $newRecord[$newCode] = $value;
                    if (isset($replacesValues[$keyCode]) && $replacesValues[$keyCode] !== '') {
                        $newRecord[$newCode] = $replacesValues[$keyCode];
                    }
                } else {
                    if (!$allFields) {
                        $newRecord[$code] = $value;
                    }
                }
            }

            $noFullList = array_diff($listCodes, array_keys($newRecord));
            if (!empty($noFullList)) {
                $newCode = '';
                foreach ($noFullList as $code => $value) {
                    if (isset($replaces[$code])) {
                        $newCode = $replaces[$code];
                    }
                    if (isset($replacesValues[$code])
                        && $replacesValues[$code] !== ''
                        && !isset($newRecord[$newCode])
                    ) {
                        $newRecord[$newCode] = $replacesValues[$code];
                    }
                    $newRecord[$code] = $value;
                }
            }
            if (!empty($newRecord)) {
                $newData[] = $newRecord;
            }
        }

        return $newData ? $newData : $data;
    }

    /**
     * @param array $list
     * @param string $search
     * @return false|int|string
     */
    protected function getKeyFromList($list, $search)
    {
        return array_search($search, $list);
    }

    /**
     * @param array $row
     * @return array
     */
    public function changeRow($row)
    {
        $listCodes = $this->_parameters['list'];
        $replaces = $this->_parameters['replace_code'];
        $allFields = $this->_parameters['all_fields'];
        $replacesValues = $this->_parameters['replace_value'];
        $newRecord = [];
        foreach ($row as $code => $value) {
            if (in_array($code, $listCodes)) {
                $keyCode = $this->getKeyFromList($listCodes, $code);
                $newCode = $code;
                if (isset($replaces[$keyCode])) {
                    $newCode = $replaces[$keyCode];
                }
                $newRecord[$newCode] = is_array($value) ? json_encode($value) : $value;
                if (isset($replacesValues[$keyCode]) && !empty($replacesValues[$keyCode])) {
                    $newRecord[$newCode] = $replacesValues[$keyCode];
                }
            } else {
                if (!$allFields) {
                    $newRecord[$code] = is_array($value) ? json_encode($value) : $value;
                }
            }
        }

//        $noFullList = array_diff($listCodes, array_keys($newRecord));
//        if (!empty($noFullList)) {
//            foreach ($noFullList as $code => $value) {
//                $newRecord[$code] = $value;
//            }
//        }

        return $newRecord;
    }

    /**
     * @param array $headers
     * @return array
     */
    public function changeHeaders($headers)
    {
        $allFields = $this->_parameters['all_fields'];
        $listCodes = $this->_parameters['list'];
        $countCodes = count($listCodes);
        $replaces = $this->_parameters['replace_code'];
        $newHeaders = [];
        foreach ($headers as $code) {
            if (in_array($code, $listCodes)) {
                $newCode = $code;
                $keyCode = $this->getKeyFromList($listCodes, $code);
                if (isset($replaces[$keyCode])) {
                    $newCode = $replaces[$keyCode];
                    $newHeaders[array_search($code, $listCodes)] = $newCode;
                } else {
                    $newHeaders[$countCodes++] = $newCode;
                }
            } else {
                if (!$allFields) {
                    $newHeaders[$countCodes++] = $code;
                }
            }
        }
        ksort($newHeaders);

        return $newHeaders ? $newHeaders : $headers;
    }

    /**
     * @return int
     */
    public function getCount()
    {
        /** @var AbstractDb $entityCollection */
        $entityCollection = $this->_getEntityCollection();
        return $entityCollection->getSize();
    }

    /**
     * @return array
     */
    public function getParameters()
    {
        return $this->_parameters;
    }

    /**
     * Apply filter to collection and add not skipped attributes to select.
     *
     * @param AbstractCollection $collection
     * @return AbstractCollection
     * @throws LocalizedException
     * @throws Exception
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     */
    protected function _prepareEntityCollection(AbstractCollection $collection)
    {
        if (!isset($this->_parameters[Export::FILTER_ELEMENT_GROUP])
            || !is_array($this->_parameters[Export::FILTER_ELEMENT_GROUP])
        ) {
            $filter = [];
        } else {
            $filter = $this->_parameters[Export::FILTER_ELEMENT_GROUP];
        }

        $exportCodes = $this->_getExportAttrCodes();

        /** @var Attribute $attribute */
        foreach ($this->filterAttributeCollection($this->getAttributeCollection()) as $attribute) {
            $attrCode = $attribute->getAttributeCode();

            // filter applying
            if (isset($filter[$attrCode])) {
                $attrFilterType = Export::getAttributeFilterType($attribute);

                if (Export::FILTER_TYPE_SELECT == $attrFilterType) {
                    if (is_scalar($filter[$attrCode])) {
                        if ($filter[$attrCode] == 0) {
                            $collection->addAttributeToFilter([
                                ['attribute' => $attrCode, 'eq' => $filter[$attrCode]],
                                ['attribute' => $attrCode, 'null' => 1],
                            ]);
                        } else {
                            $collection->addAttributeToFilter($attrCode, ['eq' => $filter[$attrCode]]);
                        }
                    }
                } elseif (Export::FILTER_TYPE_INPUT == $attrFilterType) {
                    if (is_scalar($filter[$attrCode]) && trim($filter[$attrCode])) {
                        $collection->addAttributeToFilter($attrCode, ['like' => "%{$filter[$attrCode]}%"]);
                    }
                } elseif (Export::FILTER_TYPE_DATE == $attrFilterType) {
                    if (is_array($filter[$attrCode]) && count($filter[$attrCode]) == 2) {
                        $from = array_shift($filter[$attrCode]);
                        $to = array_shift($filter[$attrCode]);

                        if (is_scalar($from) && !empty($from)) {
                            $date = (new DateTime($from))->format('m/d/Y');
                            $collection->addAttributeToFilter($attrCode, ['from' => $date, 'date' => true]);
                        }
                        if (is_scalar($to) && !empty($to)) {
                            $date = (new DateTime($to))->format('m/d/Y');
                            $collection->addAttributeToFilter($attrCode, ['to' => $date, 'date' => true]);
                        }
                    }
                } elseif (Export::FILTER_TYPE_NUMBER == $attrFilterType) {
                    if (is_array($filter[$attrCode]) && count($filter[$attrCode]) == 2) {
                        $from = array_shift($filter[$attrCode]);
                        $to = array_shift($filter[$attrCode]);

                        if (is_numeric($from)) {
                            $collection->addAttributeToFilter(
                                $attrCode,
                                ['from' => $from]
                            );
                        }
                        if (is_numeric($to)) {
                            $collection->addAttributeToFilter(
                                $attrCode,
                                ['to' => $to]
                            );
                        }
                    }
                }
            }
            if (in_array($attrCode, $exportCodes)) {
                $collection->addAttributeToSelect($attrCode);
            }
        }
        return $collection;
    }

    /**
     * Retrieve entity field for export
     *
     * @return array
     */
    public function getFieldsForExport()
    {
        return [];
    }

    /**
     * Retrieve entity field for filter
     *
     * @return array
     */
    public function getFieldsForFilter()
    {
        return [];
    }

    /**
     * Retrieve store ids for filter
     *
     * @return array
     */
    public function getStoreIdsForFilter()
    {
        if (!empty($this->_parameters['only_admin'])) {
            return [Store::DEFAULT_STORE_ID];
        }
        return $this->_parameters['behavior_data']['store_ids'] ?? [];
    }

    /**
     * Retrieve entity field columns
     *
     * @return array
     */
    public function getFieldColumns()
    {
        return [];
    }

    /**
     * Retrieve entity attribute type
     *
     * @param $type
     * @return string
     */
    private function getAttributeType($type)
    {
        if (in_array($type, ['int', 'decimal', 'price'])) {
            return 'int';
        }
        if (in_array($type, ['varchar', 'text', 'textarea'])) {
            return 'text';
        }
        if (in_array($type, ['select', 'multiselect', 'boolean'])) {
            return 'select';
        }
        if (in_array($type, ['datetime', 'date'])) {
            return 'date';
        }
        return 'not';
    }
}