<?php
/**
* Mageplaza
*
* NOTICE OF LICENSE
*
* This source file is subject to the Mageplaza.com license that is
* available through the world-wide-web at this URL:
* https://www.mageplaza.com/LICENSE.txt
*
* DISCLAIMER
*
* Do not edit or add to this file if you wish to upgrade this extension to newer
* version in the future.
*
* @category Mageplaza
* @package Mageplaza_ImportExportCMS
* @copyright Copyright (c) Mageplaza (https://www.mageplaza.com/)
* @license https://www.mageplaza.com/LICENSE.txt
*/

namespace Mageplaza\ImportExportCMS\Model;

use Exception;
use Magento\CatalogImportExport\Model\Import\Uploader;
use Magento\CatalogImportExport\Model\Import\UploaderFactory;
use Magento\Cms\Model\BlockFactory;
use Magento\Cms\Model\PageFactory;
use Magento\Framework\App\Filesystem\DirectoryList;
use Magento\Framework\App\ProductMetadataInterface;
use Magento\Framework\App\ResourceConnection;
use Magento\Framework\Data\Collection\AbstractDb;
use Magento\Framework\Exception\FileSystemException;
use Magento\Framework\Exception\LocalizedException;
use Magento\Framework\Filesystem;
use Magento\Framework\Model\AbstractModel;
use Magento\Framework\Model\Context;
use Magento\Framework\Model\ResourceModel\AbstractResource;
use Magento\Framework\Model\ResourceModel\Db\Collection\AbstractCollection;
use Magento\Framework\Registry;
use Magento\Framework\Stdlib\DateTime\DateTime;
use Magento\ImportExport\Model\Import;
use Magento\ImportExport\Model\Import\ErrorProcessing\ProcessingErrorAggregatorInterface;
use Magento\ImportExport\Model\ResourceModel\Import\Data;
use Mageplaza\ImportExportCMS\Block\Adminhtml\Import\Result;
use Mageplaza\ImportExportCMS\Model\ResourceModel\Import as ImportResource;

/**
* Class Block
*
* @method string getBehavior()
* @method string getValidationStrategy()
* @method string getAllowedErrorCount()
* @method string getImportImagesFileDir()
* @package Mageplaza\ImportExportCMS\Model
*/
abstract class AbstractImport extends AbstractModel
{
const COL_IDENTIFIER = 'identifier';
const COL_TITLE = 'title';
const COL_CONTENT = 'content';
const COL_STORE_ID = 'store_id';
const COL_CREATION_TIME = 'creation_time';
const COL_UPDATE_TIME = 'update_time';
const COL_IS_ACTIVE = 'is_active';

/**
* Valid column names
*
* @array
*/
protected $_validColumnNames = [];

/**
* @var array
*/
protected $_permanentAttributes = [];

/**
* @var bool
*/
protected $_isValid = true;

/**
* @var int
*/
protected $_checkedRow = 0;

/**
* @var int
*/
protected $_entityError = 0;

/**
* @var bool
*/
protected $_stopOnError = false;

/**
* @var bool
*/
protected $_isImportError = false;

/**
* @var Data
*/
protected $_importData;

/**
* @var DateTime
*/
protected $_dateTime;

/**
* @var BlockFactory
*/
protected $_blockFactory;

/**
* @var PageFactory
*/
protected $_pageFactory;

/**
* @var ResourceConnection
*/
protected $_resourceConnection;

/**
* @var UploaderFactory
*/
protected $_uploaderFactory;

/**
* @var Filesystem
*/
protected $_mediaDirectory;

/**
* @var ProductMetadataInterface
*/
protected $_productMetadata;

/**
* @var ImportResource
*/
protected $_importResource;

/**
* AbstractImport constructor.
*
* @param Context $context
* @param Registry $registry
* @param Data $importData
* @param DateTime $dateTime
* @param BlockFactory $blockFactory
* @param PageFactory $pageFactory
* @param ResourceConnection $resourceConnection
* @param UploaderFactory $uploaderFactory
* @param Filesystem $filesystem
* @param ProductMetadataInterface $productMetadata
* @param ImportResource $importResource
* @param AbstractResource|null $resource
* @param AbstractDb|null $resourceCollection
* @param array $data
*
* @throws FileSystemException
*/
public function __construct(
Context $context,
Registry $registry,
Data $importData,
DateTime $dateTime,
BlockFactory $blockFactory,
PageFactory $pageFactory,
ResourceConnection $resourceConnection,
UploaderFactory $uploaderFactory,
Filesystem $filesystem,
ProductMetadataInterface $productMetadata,
ImportResource $importResource,
AbstractResource $resource = null,
AbstractDb $resourceCollection = null,
array $data = []
) {
$this->_importData = $importData;
$this->_dateTime = $dateTime;
$this->_blockFactory = $blockFactory;
$this->_pageFactory = $pageFactory;
$this->_resourceConnection = $resourceConnection;
$this->_uploaderFactory = $uploaderFactory;
$this->_mediaDirectory = $filesystem->getDirectoryWrite(DirectoryList::ROOT);
$this->_productMetadata = $productMetadata;
$this->_importResource = $importResource;

parent::__construct(
$context,
$registry,
$resource,
$resourceCollection,
$data
);
}

/**
* @param array $colName
* @param Result $resultBlock
*/
public function validateColName($colName, $resultBlock)
{
$columnNumber = 0;
$emptyHeaderColumns = [];
$invalidColumns = [];
$absentColumns = array_diff($this->_permanentAttributes, $colName);

if ($absentColumns) {
$absentColumns = implode(',', $absentColumns);
$resultBlock->addError(__('Column %1 not found', $absentColumns));
$this->_isValid = false;
}
foreach ($colName as $col) {
$columnNumber++;
if (trim($col) == '') {
$emptyHeaderColumns[] = $columnNumber;
} elseif (!preg_match('/^[a-z][a-z0-9_]*$/', $col) || !in_array($col, $this->_validColumnNames)) {
$invalidColumns[] = $col;
}
}
if ($emptyHeaderColumns) {
$emptyHeaderColumns = implode(',', $emptyHeaderColumns);
$resultBlock->addError(__('Column %1 is empty', $emptyHeaderColumns));
$this->_isValid = false;
}
if ($invalidColumns) {
$invalidColumns = implode(',', $invalidColumns);
$resultBlock->addError(__('Column %1 is invalid', $invalidColumns));
$this->_isValid = false;
}
}

/**
* @param array $importProductRawData
* @param Result $resultBlock
*
* @return array
*/
public function processDataBunch($importProductRawData, $resultBlock)
{
$rowEmpty = [];
$bunch = [];
$colHeaders = $this->getColName($importProductRawData);
foreach ($importProductRawData as $rowIndex => $dataRow) {
if ($rowIndex != 0) {
$this->_checkedRow++;
if (count($dataRow) != count($colHeaders)) {
$this->_entityError++;
continue;
}
$temp = [];
foreach ($dataRow as $key => $value) {
if (is_object($value)) {
$value = (((array) $value)['Data']) ?: null;
}
if (in_array($importProductRawData[0][$key], $this->_permanentAttributes) && trim($value) == '') {
$rowEmpty[] = $importProductRawData[0][$key] . '-' . $this->_checkedRow;
$this->_isValid = false;
}
$temp[$colHeaders[$key]] = $value;
}
$bunch[] = $temp;
}
}
$this->getProcessBunchMessage($rowEmpty, $bunch, $resultBlock);

return $bunch;
}

/**
* @param array $rowEmpty
* @param array $bunch
* @param Result $resultBlock
*/
public function getProcessBunchMessage($rowEmpty, $bunch, $resultBlock)
{
if ($rowEmpty) {
$rowEmpty = implode(',', $rowEmpty);
$resultBlock->addError(__('Column & Row %1 is empty', $rowEmpty));
}
if (empty($bunch)) {
$this->_isValid = false;
$resultBlock->addError(__('Invalid entity'));
}
}

/**
* Get bunch column name
*
* @param array $importProductRawData
*
* @return array
*/
public function getColName($importProductRawData)
{
$colHeaders = [];
foreach ($importProductRawData as $rowIndex => $dataRow) {
if ($rowIndex == 0) {
foreach ($dataRow as $rowHeader) {
$colHeaders[] = (is_object($rowHeader)) ? ((array) $rowHeader)['Data'] : $rowHeader;
}
}
}

return $colHeaders;
}

/**
* Data validate status
*
* @return bool
*/
public function isValidate()
{
return $this->_isValid;
}

/**
* Checked row number
*
* @return int
*/
public function getCheckedRow()
{
return $this->_checkedRow;
}

/**
* Checked entity error number
*
* @return int
*/
public function getEntityError()
{
return $this->_entityError;
}

/**
* @return bool
*/
public function isImportError()
{
return $this->_isImportError;
}

/**
* Import process
*
* @param Result $resultBlock
*
* @throws FileSystemException
* @throws LocalizedException
*/
public function processImport($resultBlock)
{
if (Import::BEHAVIOR_DELETE == $this->getBehavior()) {
$this->deleteEntity($resultBlock);
} elseif (Import::BEHAVIOR_REPLACE == $this->getBehavior()) {
$this->replaceEntity($resultBlock);
} elseif (Import::BEHAVIOR_APPEND == $this->getBehavior()) {
$this->saveEntity($resultBlock);
}
}

/**
* Save import action
*
* @param Result $resultBlock
*
* @throws FileSystemException
* @throws LocalizedException
*/
public function saveEntity($resultBlock)
{
$this->_saveAndReplaceEntity($resultBlock);
}

/**
* Replace import action
*
* @param Result $resultBlock
*
* @throws FileSystemException
* @throws LocalizedException
*/
public function replaceEntity($resultBlock)
{
$this->_saveAndReplaceEntity($resultBlock);
}

/**
* Delete action
*
* @param Result $resultBlock
*/
public function deleteEntity($resultBlock)
{
$listIdentifier = [];
while ($bunch = $this->_importData->getNextBunch()) {
foreach ($bunch as $rowData) {
$listIdentifier[] = $rowData[self::COL_IDENTIFIER];
}
}
if ($listIdentifier && $deleteCnt = $this->_deleteEntityFinish(array_unique($listIdentifier), $resultBlock)) {
$resultBlock->addSuccess(__('You have deleted %1 records successful', $deleteCnt));
} else {
$resultBlock->addSuccess(__('No row is updated'));
}
}

/**
* @param array $entityList
* @param Result $resultBlock
* @param array $cmsInfo
* @param string $type
*/
protected function _saveEntityFinish(array $entityList, $resultBlock, $cmsInfo, $type)
{
if ($entityList) {
$updateCnt = 0;
$addCnt = 0;
$errorCnt = 0;
foreach ($entityList as $row) {
$cmsInfo['model']->setData($row);
try {
if ($cmsId = $this->_importResource->isUniqueCmsToStores(
$row,
$cmsInfo['cms_id'],
$cmsInfo['table_name'],
$cmsInfo['store_table_name']
)) {
unset($row[self::COL_STORE_ID]);
$this->_getCmsById($cmsId)->addData($row)->save();
$updateCnt++;
} else {
$cmsInfo['model']->save();
$addCnt++;
}
} catch (Exception $e) {
$this->_isImportError = true;
$resultBlock->addError($e->getMessage());
$errorCnt++;
if ($this->getValidationStrategy()
== ProcessingErrorAggregatorInterface::VALIDATION_STRATEGY_STOP_ON_ERROR) {
$this->_stopOnError = true;
}
if ($errorCnt >= (int) $this->getAllowedErrorCount()) {
$this->_stopOnError = true;
}
}
if ($this->_stopOnError) {
break;
}
}

$this->_uploadFile($resultBlock);
$this->_addImportResultMessage($updateCnt, Import::BEHAVIOR_ADD_UPDATE, $resultBlock);
$this->_addImportResultMessage($addCnt, $type, $resultBlock);
$this->_addImportResultMessage($errorCnt, 'error', $resultBlock);
}
}

/**
* @param Result $resultBlock
*
* @throws FileSystemException
* @throws LocalizedException
*/
abstract protected function _saveAndReplaceEntity($resultBlock);

/**
* @return AbstractCollection
*/
abstract protected function _getCmsCollection();

/**
* @param string $cmsId
*
* @return AbstractModel
*/
abstract protected function _getCmsById($cmsId);

/**
* @param array $listIdentifier
* @param Result $resultBlock
*
* @return bool|int
*/
protected function _deleteEntityFinish(array $listIdentifier, $resultBlock)
{
if ($listIdentifier) {
$deleteCnt = 0;
try {
/** @var AbstractCollection $collection */
$collection = $this->_getCmsCollection();
foreach ($collection as $item) {
if (in_array($item->getIdentifier(), $listIdentifier)) {
$item->delete();
$deleteCnt++;
}
}

return $deleteCnt;
} catch (Exception $e) {
$this->_isImportError = true;
$resultBlock->addError($e->getMessage());

return false;
}
} else {
return false;
}
}

/**
* @param Result $resultBlock
* @param string $childFolder
*
* @return Uploader
*/
protected function _uploadFile($resultBlock, $childFolder = '')
{
/** @var Uploader $fileUploader */
$fileUploader = $this->_uploaderFactory->create();
$fileUploader->setAllowedExtensions(['jpg', 'jpeg', 'gif', 'png']);
$dirConfig = DirectoryList::getDefaultConfig();
$dirAddOn = $dirConfig[DirectoryList::MEDIA][DirectoryList::PATH];
$tmpPath = (!empty($this->getImportImagesFileDir()))
? $this->getImportImagesFileDir() . $childFolder
: $dirAddOn . DIRECTORY_SEPARATOR . $this->_mediaDirectory
->getRelativePath('import' . DIRECTORY_SEPARATOR . $childFolder);

try {
$fileUploader->setTmpDir($tmpPath);
$destinationPath = $dirAddOn . DIRECTORY_SEPARATOR . $this
->_mediaDirectory->getRelativePath('wysiwyg' . DIRECTORY_SEPARATOR . $childFolder);
$this->_mediaDirectory->create($destinationPath);
$fileUploader->setDestDir($destinationPath);
$files = scandir($tmpPath);
foreach ($files as $file) {
$fileExtension = pathinfo($file, PATHINFO_EXTENSION);
if ($file !== '.' && $file !== '..' && $fileUploader->checkAllowedExtension($fileExtension)) {
$fileUploader->move($file);
} elseif ($file !== '.' && $file !== '..' && is_dir($tmpPath . '/' . $file)) {
$this->_uploadFile($resultBlock, $childFolder . DIRECTORY_SEPARATOR . $file);
}
}
} catch (Exception $e) {
$this->_isImportError = true;
$resultBlock->addError($e->getMessage());
}

return $fileUploader;
}

/**
* @param int $count
* @param string $type
* @param Result $resultBlock
*/
protected function _addImportResultMessage($count, $type, $resultBlock)
{
switch ($type) {
case Import::BEHAVIOR_ADD_UPDATE:
$messageText = __(__('You have updated %1 record(s)', $count));
if ($count) {
$resultBlock->addSuccess($messageText);
}
break;
case Import::BEHAVIOR_APPEND:
$messageText = __(__('You have added %1 record(s)', $count));
if ($count) {
$resultBlock->addSuccess($messageText);
}
break;
case Import::BEHAVIOR_REPLACE:
$messageText = __(__('You have replaced %1 record(s)', $count));
if ($count) {
$resultBlock->addSuccess($messageText);
}
break;
case 'error':
$messageText = __(__('%1 error(s)', $count));
if ($count) {
$resultBlock->addError($messageText);
}
break;
}
}
}