├── Api
    ├── CmsEntityConverterManagerInterface.php
    ├── CmsEntityGeneratorManagerInterface.php
    ├── ContentExportInterface.php
    ├── ContentImportInterface.php
    ├── ContentVersionManagementInterface.php
    ├── ContentVersionRepositoryInterface.php
    ├── Data
    │   └── ContentVersionInterface.php
    └── StoreManagementInterface.php
├── Block
    └── Adminhtml
    │   ├── Cms
    │       ├── Block
    │       │   └── Edit
    │       │   │   └── History.php
    │       ├── CmsAbstract.php
    │       └── Page
    │       │   └── Edit
    │       │       └── History.php
    │   └── Import
    │       └── Button
    │           └── Import.php
├── CHANGELOG.md
├── Console
    └── Command
    │   ├── CMSUpgradeCommand.php
    │   ├── ClearCMSHistoryCommand.php
    │   └── ImportContent.php
├── Controller
    └── Adminhtml
    │   ├── AbstractMassExport.php
    │   ├── Block
    │       └── MassExport.php
    │   ├── History
    │       ├── Apply.php
    │       └── View.php
    │   ├── Import
    │       ├── Import.php
    │       ├── Index.php
    │       └── Upload.php
    │   └── Page
    │       └── MassExport.php
├── Cron
    └── DeleteBackups.php
├── Exception
    └── InvalidXmlImportFilesException.php
├── File
    ├── FileManager.php
    └── FileManagerInterface.php
├── LICENSE.txt
├── Model
    ├── BackupManager.php
    ├── Config.php
    ├── Config
    │   ├── App
    │   │   └── FileResolver.php
    │   ├── Block
    │   │   ├── Converter.php
    │   │   ├── Reader.php
    │   │   └── SchemaLocator.php
    │   ├── ConverterAbstract.php
    │   ├── Cron
    │   │   └── SaveValue.php
    │   ├── Page
    │   │   ├── Converter.php
    │   │   ├── Reader.php
    │   │   └── SchemaLocator.php
    │   ├── ReaderAbstract.php
    │   └── SchemaLocatorAbstract.php
    ├── Content
    │   ├── Converter
    │   │   ├── AbstractConverter.php
    │   │   ├── Block
    │   │   │   └── Converter.php
    │   │   ├── CmsEntityConverterInterface.php
    │   │   ├── CmsEntityConverterManager.php
    │   │   └── Page
    │   │   │   └── Converter.php
    │   ├── Export.php
    │   ├── Generator
    │   │   ├── CmsEntityGeneratorInterface.php
    │   │   ├── CmsEntityGeneratorManager.php
    │   │   ├── Json
    │   │   │   └── Generator.php
    │   │   └── Xml
    │   │   │   └── Generator.php
    │   └── Import.php
    ├── ContentVersion.php
    ├── ContentVersionManagement.php
    ├── ContentVersionRepository.php
    ├── Dir
    │   └── Reader.php
    ├── EntityManagement.php
    ├── OptionSource
    │   ├── CmsMode.php
    │   ├── MediaMode.php
    │   ├── Methods.php
    │   └── Periods.php
    ├── ResourceModel
    │   ├── ContentVersion.php
    │   └── ContentVersion
    │   │   └── Collection.php
    ├── Service
    │   ├── ClearCMSHistory.php
    │   ├── GetCmsEntityItems.php
    │   └── GetContentVersions.php
    └── StoreManagement.php
├── Observer
    ├── CmsSaveBefore.php
    └── DeleteContentVersion.php
├── README.md
├── Setup
    └── Recurring.php
├── Test
    └── Unit
    │   ├── Block
    │       └── Adminhtml
    │       │   └── Cms
    │       │       └── CmsAbstractTest.php
    │   ├── Controller
    │       └── Adminhtml
    │       │   ├── Block
    │       │       └── MassExportTest.php
    │       │   ├── History
    │       │       └── ViewTest.php
    │       │   ├── Import
    │       │       ├── ImportTest.php
    │       │       ├── IndexTest.php
    │       │       └── UploadTest.php
    │       │   └── Page
    │       │       └── MassExportTest.php
    │   ├── Model
    │       ├── BackupManagerTest.php
    │       ├── Config
    │       │   ├── App
    │       │   │   └── FileResolverTest.php
    │       │   └── ConverterAbstractTest.php
    │       ├── ConfigTest.php
    │       ├── ContentVersionManagementTest.php
    │       ├── ContentVersionRepositoryTest.php
    │       ├── Service
    │       │   └── ClearCMSHistoryTest.php
    │       └── StoreManagementTest.php
    │   └── Observer
    │       └── CmsSaveBeforeTest.php
├── Ui
    └── DataProvider
    │   ├── HistoryView.php
    │   └── Import.php
├── composer.json
├── etc
    ├── acl.xml
    ├── adminhtml
    │   ├── events.xml
    │   ├── menu.xml
    │   ├── routes.xml
    │   └── system.xml
    ├── cms_block_data.xsd
    ├── cms_page_data.xsd
    ├── config.xml
    ├── crontab.xml
    ├── db_schema.xml
    ├── di.xml
    ├── module.xml
    └── od_cms
    │   ├── cms_block_data.xml.sample
    │   ├── cms_page_data.xml.sample
    │   └── cms_page_data_no-route.xml.sample
├── registration.php
└── view
    └── adminhtml
        ├── layout
            ├── cmscontent_history_view.xml
            └── cmscontent_import_index.xml
        ├── templates
            ├── cms
            │   └── backup
            │   │   └── history.phtml
            └── history
            │   └── view.phtml
        └── ui_component
            ├── cms_block_form.xml
            ├── cms_block_listing.xml
            ├── cms_page_form.xml
            ├── cms_page_listing.xml
            ├── cmscontent_import_form.xml
            └── overdose_cmscontent_historyview_form.xml


/Api/CmsEntityConverterManagerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Api;
 6 | 
 7 | use Magento\Framework\Exception\LocalizedException;
 8 | use Overdose\CMSContent\Model\Content\Converter\CmsEntityConverterInterface;
 9 | 
10 | interface CmsEntityConverterManagerInterface
11 | {
12 |     /**#@+
13 |      * Entity Types
14 |      */
15 |     const PAGE_ENTITY_CODE = 'pages';
16 |     const BLOCK_ENTITY_CODE = 'blocks';
17 |     /**#@-*/
18 | 
19 |     /**
20 |      * Get converter by Entity
21 |      *
22 |      * @param string $type
23 |      *
24 |      * @return CmsEntityConverterInterface
25 |      * @throws LocalizedException
26 |      */
27 |     public function getConverter(string $type): CmsEntityConverterInterface;
28 | }
29 | 


--------------------------------------------------------------------------------
/Api/CmsEntityGeneratorManagerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Api;
 6 | 
 7 | use Magento\Framework\Exception\LocalizedException;
 8 | use Overdose\CMSContent\Model\Content\Generator\CmsEntityGeneratorInterface;
 9 | 
10 | interface CmsEntityGeneratorManagerInterface
11 | {
12 |     /**
13 |      * Get generator
14 |      *
15 |      * @param string $type
16 |      *
17 |      * @return CmsEntityGeneratorInterface
18 |      * @throws LocalizedException
19 |      */
20 |     public function getGenerator(string $type): CmsEntityGeneratorInterface;
21 | }
22 | 


--------------------------------------------------------------------------------
/Api/ContentExportInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Api;
 6 | 
 7 | use Magento\Framework\Exception\FileSystemException;
 8 | use Magento\Framework\Exception\LocalizedException;
 9 | 
10 | interface ContentExportInterface
11 | {
12 |     /**
13 |      * Create a zip file and return its name
14 |      *
15 |      * @param array $convertedEntities
16 |      * @param string $entityType
17 |      * @param string $type
18 |      * @param string $fileName
19 |      * @param bool $split
20 |      *
21 |      * @return string
22 |      * @throws FileSystemException|LocalizedException
23 |      */
24 |     public function createZipFile(
25 |         array $convertedEntities,
26 |         string $entityType,
27 |         string $type,
28 |         string $fileName,
29 |         bool $split
30 |     ): string;
31 | }
32 | 


--------------------------------------------------------------------------------
/Api/ContentImportInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Api;
 6 | 
 7 | use Exception;
 8 | 
 9 | interface ContentImportInterface
10 | {
11 |     const OD_CMS_MODE_UPDATE = 'update';
12 |     const OD_CMS_MODE_SKIP = 'skip';
13 | 
14 |     const OD_MEDIA_MODE_NONE = 'none';
15 |     const OD_MEDIA_MODE_UPDATE = 'update';
16 |     const OD_MEDIA_MODE_SKIP = 'skip';
17 | 
18 |     const MEDIA_ARCHIVE_PATH = 'media';
19 | 
20 |     /**
21 |      * Import contents from zip archive and return number of imported records (-1 on error)
22 |      *
23 |      * @param string $fileName
24 |      * @param bool $rm
25 |      *
26 |      * @return int
27 |      * @throws Exception
28 |      */
29 |     public function importContentFromZipFile(string $fileName, bool $rm): int;
30 | 
31 |     /**
32 |      * Set CMS mode on import
33 |      *
34 |      * @param string $mode
35 |      *
36 |      * @return ContentImportInterface
37 |      */
38 |     public function setCmsModeOption(string $mode): ContentImportInterface;
39 | 
40 |     /**
41 |      * Set media mode on import
42 |      *
43 |      * @param string $mode
44 |      *
45 |      * @return ContentImportInterface
46 |      */
47 |     public function setMediaModeOption(string $mode): ContentImportInterface;
48 | }
49 | 


--------------------------------------------------------------------------------
/Api/ContentVersionManagementInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Api;
 6 | 
 7 | use Magento\Framework\Exception\LocalizedException;
 8 | use Overdose\CMSContent\Exception\InvalidXmlImportFilesException;
 9 | 
10 | interface ContentVersionManagementInterface
11 | {
12 |     const DEFAULT_VERSION = '1.0.0';
13 |     const XML_FILE_HEADER_LENGTH = 150;
14 | 
15 |     /**
16 |      * Process update for all changed CMSContent records
17 |      *
18 |      * @return void
19 |      */
20 |     public function processAll(): void;
21 | 
22 |     /**
23 |      * Update blocks CMSContent records
24 |      *
25 |      * @param array $ids
26 |      *
27 |      * @return void
28 |      */
29 |     public function processBlocks(array $ids = []): void;
30 | 
31 |     /**
32 |      * Update pages CMSContent records
33 |      *
34 |      * @param array $ids
35 |      *
36 |      * @return void
37 |      */
38 |     public function processPages(array $ids = []): void;
39 | 
40 |     /**
41 |      * Process update for all CMSContent records from file
42 |      *
43 |      * @param string $filePath
44 |      *
45 |      * @throws InvalidXmlImportFilesException
46 |      * @throws LocalizedException
47 |      * @return int - count of processed entities
48 |      */
49 |     public function processFile(string $filePath): int;
50 | 
51 |     /**
52 |      * Update data for selected CMSContent record
53 |      *
54 |      * @param $contentVersion
55 |      * @param $configItem
56 |      *
57 |      * @return ContentVersionManagementInterface
58 |      */
59 |     public function updateVersion($contentVersion, $configItem): ContentVersionManagementInterface;
60 | 
61 |     /**
62 |      * Create CMSContent record
63 |      *
64 |      * @param int $type
65 |      * @param array $data
66 |      *
67 |      * @return ContentVersionManagementInterface
68 |      */
69 |     public function createVersion(int $type, array $data): ContentVersionManagementInterface;
70 | 
71 |     /**
72 |      * Retrieves current version number based on identifier and type (0 - blocks, 1-pages)
73 |      *
74 |      * @param string $id
75 |      * @param int $type
76 |      * @param string|null $storeIds
77 |      *
78 |      * @return string
79 |      */
80 |     public function getCurrentVersion(string $id, int $type, ?string $storeIds): string;
81 | 
82 |     /**
83 |      * Delete content version model based on identifier and type (0 - blocks, 1-pages)
84 |      *
85 |      * @param string $id
86 |      * @param int $type
87 |      * @param array $storeIds
88 |      *
89 |      * @return mixed
90 |      */
91 |     public function deleteContentVersion(string $id, int $type, array $storeIds);
92 | }
93 | 


--------------------------------------------------------------------------------
/Api/ContentVersionRepositoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Api;
 6 | 
 7 | use Magento\Framework\Api\SearchCriteriaInterface;
 8 | use Magento\Framework\Api\SearchResultsInterface;
 9 | use Magento\Framework\Exception\LocalizedException;
10 | use Magento\Framework\Exception\NoSuchEntityException;
11 | use Overdose\CMSContent\Api\Data\ContentVersionInterface;
12 | 
13 | interface ContentVersionRepositoryInterface
14 | {
15 |     /**
16 |      * Save content_version
17 |      *
18 |      * @param ContentVersionInterface $contentVersion
19 |      *
20 |      * @return ContentVersionInterface
21 |      * @throws LocalizedException
22 |      */
23 |     public function save(ContentVersionInterface $contentVersion): ContentVersionInterface;
24 | 
25 |     /**
26 |      * Retrieve content_version
27 |      *
28 |      * @param string $id
29 |      *
30 |      * @return ContentVersionInterface
31 |      * @throws LocalizedException
32 |      */
33 |     public function get(string $id): ContentVersionInterface;
34 | 
35 |     /**
36 |      * Retrieve content_version matching the specified criteria.
37 |      *
38 |      * @param SearchCriteriaInterface $searchCriteria
39 |      *
40 |      * @return SearchResultsInterface
41 |      * @throws LocalizedException
42 |      */
43 |     public function getList(SearchCriteriaInterface $searchCriteria): SearchResultsInterface;
44 | 
45 |     /**
46 |      * Delete content_version
47 |      *
48 |      * @param ContentVersionInterface $contentVersion
49 |      *
50 |      * @return bool true on success
51 |      * @throws LocalizedException
52 |      */
53 |     public function delete(ContentVersionInterface $contentVersion): bool;
54 | 
55 |     /**
56 |      * Delete content_version by ID
57 |      *
58 |      * @param string $id
59 |      *
60 |      * @return bool true on success
61 |      * @throws NoSuchEntityException
62 |      * @throws LocalizedException
63 |      */
64 |     public function deleteById(string $id): bool;
65 | }
66 | 


--------------------------------------------------------------------------------
/Api/Data/ContentVersionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Api\Data;
 6 | 
 7 | interface ContentVersionInterface
 8 | {
 9 |     /**#@+
10 |      * Entity Fields
11 |      */
12 |     const IDENTIFIER = 'identifier';
13 |     const STORE_IDS = 'store_ids';
14 |     const ID = 'id';
15 |     const VERSION = 'version';
16 |     const TYPE = 'type';
17 |     /**#@-*/
18 | 
19 |     /**#@+
20 |      * Types
21 |      */
22 |     const TYPE_BLOCK = 0;
23 |     const TYPE_PAGE = 1;
24 |     /**#@-*/
25 | 
26 |     /**
27 |      * Get type
28 |      *
29 |      * @return string|null
30 |      */
31 |     public function getType(): ?string;
32 | 
33 |     /**
34 |      * Set type
35 |      *
36 |      * @param string $type
37 |      *
38 |      * @return ContentVersionInterface
39 |      */
40 |     public function setType(string $type): ContentVersionInterface;
41 | 
42 |     /**
43 |      * Get identifier
44 |      *
45 |      * @return string|null
46 |      */
47 |     public function getIdentifier(): ?string;
48 | 
49 |     /**
50 |      * Set identifier
51 |      *
52 |      * @param string $identifier
53 |      *
54 |      * @return ContentVersionInterface
55 |      */
56 |     public function setIdentifier(string $identifier): ContentVersionInterface;
57 | 
58 |     /**
59 |      * Get version
60 |      *
61 |      * @return string|null
62 |      */
63 |     public function getVersion(): ?string;
64 | 
65 |     /**
66 |      * Set version
67 |      *
68 |      * @param string $version
69 |      *
70 |      * @return ContentVersionInterface
71 |      */
72 |     public function setVersion(string $version): ContentVersionInterface;
73 | 
74 |     /**
75 |      * Get store_ids
76 |      *
77 |      * @return string|null
78 |      */
79 |     public function getStoreIds(): ?string;
80 | 
81 |     /**
82 |      * Set store_ids
83 |      *
84 |      * @param string $storeIds
85 |      *
86 |      * @return ContentVersionInterface
87 |      */
88 |     public function setStoreIds(string $storeIds): ContentVersionInterface;
89 | }
90 | 


--------------------------------------------------------------------------------
/Api/StoreManagementInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Api;
 6 | 
 7 | interface StoreManagementInterface
 8 | {
 9 |     /**
10 |      * @param array $storeCodes
11 |      *
12 |      * @return array
13 |      */
14 |     public function getStoreIdsByCodes(array $storeCodes): array;
15 | }
16 | 


--------------------------------------------------------------------------------
/Block/Adminhtml/Cms/Block/Edit/History.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Block\Adminhtml\Cms\Block\Edit;
 6 | 
 7 | use Overdose\CMSContent\Block\Adminhtml\Cms\CmsAbstract;
 8 | use Overdose\CMSContent\Model\BackupManager;
 9 | 
10 | class History extends CmsAbstract
11 | {
12 |     protected $urlParamId = 'block_id';
13 |     protected $bcType = BackupManager::TYPE_CMS_BLOCK;
14 | }
15 | 


--------------------------------------------------------------------------------
/Block/Adminhtml/Cms/CmsAbstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Block\Adminhtml\Cms;
  6 | 
  7 | use Magento\Cms\Api\Data\BlockInterface;
  8 | use Magento\Cms\Api\Data\PageInterface;
  9 | use Magento\Framework\View\Element\Template;
 10 | use Magento\Framework\Exception\LocalizedException;
 11 | use Magento\Cms\Api\BlockRepositoryInterface;
 12 | use Magento\Cms\Api\PageRepositoryInterface;
 13 | use Magento\Backend\Model\UrlInterface;
 14 | use Overdose\CMSContent\Model\BackupManager;
 15 | 
 16 | class CmsAbstract extends Template
 17 | {
 18 |     protected $urlParamId = 'id';
 19 |     protected $bcType = null;
 20 | 
 21 |     /**
 22 |      * @var PageRepositoryInterface
 23 |      */
 24 |     private $pageRepository;
 25 | 
 26 |     /**
 27 |      * @var BackupManager
 28 |      */
 29 |     private $backupManager;
 30 | 
 31 |     /**
 32 |      * @var BlockRepositoryInterface
 33 |      */
 34 |     private $blockRepository;
 35 | 
 36 |     /**
 37 |      * @var UrlInterface
 38 |      */
 39 |     private $backendUrl;
 40 | 
 41 |     /**
 42 |      * CmsAbstract constructor.
 43 |      *
 44 |      * @param Template\Context $context
 45 |      * @param BlockRepositoryInterface $blockRepository
 46 |      * @param PageRepositoryInterface $pageRepository
 47 |      * @param BackupManager $backupManager
 48 |      * @param UrlInterface $backendUrl
 49 |      * @param array $data
 50 |      */
 51 |     public function __construct(
 52 |         Template\Context $context,
 53 |         BlockRepositoryInterface $blockRepository,
 54 |         PageRepositoryInterface $pageRepository,
 55 |         BackupManager $backupManager,
 56 |         UrlInterface $backendUrl,
 57 |         array $data = []
 58 |     ) {
 59 |         parent::__construct($context, $data);
 60 |         $this->pageRepository = $pageRepository;
 61 |         $this->backupManager = $backupManager;
 62 |         $this->blockRepository = $blockRepository;
 63 |         $this->backendUrl = $backendUrl;
 64 |     }
 65 | 
 66 |     /**
 67 |      * Prepare backups list
 68 |      *
 69 |      * @return array
 70 |      * @throws LocalizedException
 71 |      */
 72 |     public function getBackups(): array
 73 |     {
 74 |         $id = $this->getRequest()->getParam($this->urlParamId);
 75 |         $cmsObject = $this->getCmsObject($id);
 76 | 
 77 |         return $this->backupManager->getBackupsByCmsEntity($this->bcType, $cmsObject);
 78 |     }
 79 | 
 80 |     /**
 81 |      * Retrieve url for viewing of backup content
 82 |      *
 83 |      * @param $backup
 84 |      * @return string
 85 |      */
 86 |     public function getBackupUrl($backup)
 87 |     {
 88 |         return $this->backendUrl->getUrl(
 89 |             'cmscontent/history/view',
 90 |             [
 91 |                 'bc_type' => $this->bcType,
 92 |                 'bc_identifier' => $backup['identifier'],
 93 |                 'item' => $backup['name'],
 94 |                 'store_id' => $backup['store_id']
 95 |             ]
 96 |         );
 97 |     }
 98 | 
 99 |     /**
100 |      * Retrieve url for viewing of backup content
101 |      *
102 |      * @param $backup
103 |      * @return string
104 |      */
105 |     public function getBackupApplyUrl($backup)
106 |     {
107 |         return $this->backendUrl->getUrl(
108 |             'cmscontent/history/apply',
109 |             [
110 |                 'item_id' => $this->getRequest()->getParam($this->urlParamId),
111 |                 'bc_type' => $this->bcType,
112 |                 'bc_identifier' => $backup['identifier'],
113 |                 'item' => $backup['name'],
114 |                 'store_id' => $backup['store_id']
115 |             ]
116 |         );
117 |     }
118 | 
119 |     /**
120 |      * Retrieve cms block or cms page by identifier
121 |      *
122 |      * @param $id
123 |      *
124 |      * @return BlockInterface|PageInterface|null
125 |      */
126 |     public function getCmsObject($id)
127 |     {
128 |         try {
129 |             if ($this->bcType == BackupManager::TYPE_CMS_BLOCK) {
130 |                 return $this->blockRepository->getById($id);
131 |             } else if ($this->bcType == BackupManager::TYPE_CMS_PAGE) {
132 |                 return $this->pageRepository->getById($id);
133 |             }
134 | 
135 |             return null;
136 |         } catch (LocalizedException $e) {
137 |             $this->_logger->critical(__('Something went wrong while getting cms block or page %1', $id));
138 |         } catch (\Exception $e) {
139 |             $this->_logger->critical(__('Something went wrong with block or page %1', $id));
140 |         }
141 |     }
142 | }
143 | 


--------------------------------------------------------------------------------
/Block/Adminhtml/Cms/Page/Edit/History.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Block\Adminhtml\Cms\Page\Edit;
 6 | 
 7 | use Overdose\CMSContent\Block\Adminhtml\Cms\CmsAbstract;
 8 | use Overdose\CMSContent\Model\BackupManager;
 9 | 
10 | class History extends CmsAbstract
11 | {
12 |     protected $urlParamId = 'page_id';
13 |     protected $bcType = BackupManager::TYPE_CMS_PAGE;
14 | }
15 | 


--------------------------------------------------------------------------------
/Block/Adminhtml/Import/Button/Import.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Block\Adminhtml\Import\Button;
 6 | 
 7 | use Magento\Framework\View\Element\UiComponent\Control\ButtonProviderInterface;
 8 | 
 9 | class Import implements ButtonProviderInterface
10 | {
11 |     /**
12 |      * @return array
13 |      */
14 |     public function getButtonData(): array
15 |     {
16 |         return [
17 |             'label'      => __('Import'),
18 |             'class'      => 'action-secondary',
19 |             'sort_order' => 20,
20 |             'on_click'   => '',
21 |             'data_attribute' => [
22 |                 'mage-init' => [
23 |                     'buttonAdapter' => [
24 |                         'actions' => [
25 |                             [
26 |                                 'targetName' => 'cmscontent_import_form.cmscontent_import_form',
27 |                                 'actionName' => 'save',
28 |                                 'params' => [
29 |                                     false
30 |                                 ]
31 |                             ]
32 |                         ]
33 |                     ]
34 |                 ]
35 |             ],
36 |         ];
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | All notable changes to this project will be documented in this file.
 3 | 
 4 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 5 | and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 6 | 
 7 | ## [2.0.5] - 25-04-2024
 8 | ### Fix
 9 | - Fix return type for console commands.
10 | - Fix rivate variable from parent class (`Model\Dir\Reader`).
11 | 
12 | ## [2.0.4] - 17-07-2023
13 | ### Fix
14 | - Fix the issue with the argument type in `Console\Command\ImportContent`.
15 | 
16 | ## [2.0.3] - 09-01-2023
17 | ### Changed
18 | - Use the Core module for configuration tab.
19 | 
20 | ## [2.0.2] - 31-10-2022
21 | ### Added
22 | - Unit tests for Block, Model and Controller classes.
23 | 
24 | ### Changed
25 | - Made minor change in code to fix php8.1 compatibility issue.
26 | - Updated return type of function.
27 | 
28 | ### Removed
29 | - Removed leftover docblock params for a function.q
30 | 
31 | ## [2.0.1] - 30-10-2022
32 | ### Added
33 | - Backup preview now show title and identifier.
34 | - Added Apply button with confirm popup to recover page builder content and save block/page content.
35 | ### Changed
36 | - Backup preview now in json format.
37 | - Updated notes for "Clear history" feature. (Make it more clear).
38 | - Enable module by default.
39 | - Some BE refactoring.
40 | ### Removed
41 | - Removed menu item "View history" and config for this.
42 | 
43 | ## [2.0.0] - 26-06-2022
44 | ### Added
45 | - Feature "clear history"  
46 |   -- Automatic deleting an old history files by crone  
47 |   -- CLI command for clearing history files
48 | - Feature "separate files support" (you can import/export to/from separate xml/json files).
49 | - Simple Unit Test for some thin places.
50 | 
51 | ### Changed
52 | - Refactored code.
53 | - Position of system configs.
54 | - Import form moved to UI instead of direct blocks.
55 | - Support store ID.
56 | 
57 | ### Fixed
58 | - Using system configs.
59 | 
60 | ## [1.1.0] - 10-06-2022
61 | ### Added
62 | - Possibility to import/export CMS pages or blocks.
63 | - Automatic deleting an old history backups.
64 | - Refactored code.
65 | 
66 | 


--------------------------------------------------------------------------------
/Console/Command/CMSUpgradeCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Console\Command;
  6 | 
  7 | use Symfony\Component\Console\Command\Command;
  8 | use Symfony\Component\Console\Input\InputOption;
  9 | use Symfony\Component\Console\Input\InputInterface;
 10 | use Symfony\Component\Console\Output\OutputInterface;
 11 | use Overdose\CMSContent\Api\ContentVersionManagementInterface;
 12 | 
 13 | class CMSUpgradeCommand extends Command
 14 | {
 15 |     /**
 16 |      * Type option
 17 |      */
 18 |     const OPTION_CMS_TYPE = 'type';
 19 | 
 20 |     /**
 21 |      * Identifier option
 22 |      */
 23 |     const OPTION_CMS_IDENTIFIER = 'identifier';
 24 | 
 25 |     /**
 26 |      * @var ContentVersionManagementInterface
 27 |      */
 28 |     private $contentVersionManagement;
 29 | 
 30 |     /**
 31 |      * CMSUpgradeCommand constructor.
 32 |      *
 33 |      * @param ContentVersionManagementInterface $contentVersionManagement
 34 |      * @param null $name
 35 |      */
 36 |     public function __construct(
 37 |         ContentVersionManagementInterface $contentVersionManagement,
 38 |         $name = null
 39 |     ) {
 40 |         parent::__construct($name);
 41 |         $this->contentVersionManagement = $contentVersionManagement;
 42 |     }
 43 | 
 44 |     /**
 45 |      * @inheritdoc
 46 |      */
 47 |     protected function configure()
 48 |     {
 49 |         $this->setName('od:cms:upgrade')
 50 |             ->setDescription('CMS page/blocks upgrade configuration')
 51 |             ->setDefinition([
 52 |                 new InputOption(
 53 |                     'type',
 54 |                     '-t',
 55 |                     InputOption::VALUE_REQUIRED,
 56 |                     'CMS-type to upgrade: [block|blocks|page|pages]'
 57 |                 ),
 58 |                 new InputOption(
 59 |                     'identifier',
 60 |                     '-i',
 61 |                     InputOption::VALUE_REQUIRED,
 62 |                     'Comma-separated Identifiers of Block/Page to upgrade'
 63 |                 ),
 64 | 
 65 |             ]);
 66 | 
 67 |         parent::configure();
 68 |     }
 69 | 
 70 |     /**
 71 |      * @inheritdoc
 72 |      */
 73 |     protected function execute(InputInterface $input, OutputInterface $output)
 74 |     {
 75 |         $identifiers = [];
 76 |         $cmsIdentifier = $input->getOption(self::OPTION_CMS_IDENTIFIER);
 77 |         if (!empty($cmsIdentifier)) {
 78 |             $identifiers = explode(',', $cmsIdentifier);
 79 |         }
 80 | 
 81 |         $cmsType = $input->getOption(self::OPTION_CMS_TYPE);
 82 |         if (empty($cmsType) && !empty($cmsIdentifier)) {
 83 |             throw new \InvalidArgumentException('CMS Entity type OPTION [--type] missed');
 84 |         }
 85 | 
 86 |         if (!empty($cmsType)) {
 87 |             switch ($cmsType) {
 88 |                 case 'block':
 89 |                 case 'blocks':
 90 |                     $this->contentVersionManagement->processBlocks($identifiers);
 91 |                     break;
 92 |                 case 'page':
 93 |                 case 'pages':
 94 |                      $this->contentVersionManagement->processPages($identifiers);
 95 |                     break;
 96 |                 default:
 97 |                     throw new \InvalidArgumentException($cmsType . ' is incorrect CMS entity type');
 98 |             }
 99 |         } else {
100 |             $this->contentVersionManagement->processAll();
101 |         }
102 |         $output->writeln('<info>Upgrade Completed!</info>');
103 | 
104 |         return 0;
105 |     }
106 | }
107 | 


--------------------------------------------------------------------------------
/Console/Command/ClearCMSHistoryCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Console\Command;
 6 | 
 7 | use Overdose\CMSContent\Model\Config;
 8 | use Overdose\CMSContent\Model\Service\ClearCMSHistory;
 9 | use Symfony\Component\Console\Command\Command;
10 | use Symfony\Component\Console\Input\InputInterface;
11 | use Symfony\Component\Console\Input\InputOption;
12 | use Symfony\Component\Console\Output\OutputInterface;
13 | 
14 | class ClearCMSHistoryCommand extends Command
15 | {
16 |     /**
17 |      * @var ClearCMSHistory
18 |      */
19 |     private $clearCMSHistory;
20 | 
21 |     /**
22 |      * ClearCMSHistoryCommand constructor
23 |      *
24 |      * @param ClearCMSHistory $clearCMSHistory
25 |      */
26 |     public function __construct(
27 |         ClearCMSHistory $clearCMSHistory
28 |     ) {
29 |         parent::__construct();
30 |         $this->clearCMSHistory = $clearCMSHistory;
31 |     }
32 | 
33 |     /**
34 |      * @inheritdoc
35 |      */
36 |     protected function configure(): void
37 |     {
38 |         $this->setName('od:cms:history-clear')
39 |             ->setDescription('Delete old CMS history files.')
40 |             ->setDefinition([
41 |                 new InputOption(
42 |                     'type',
43 |                     '-t',
44 |                     InputOption::VALUE_REQUIRED,
45 |                     'CMS-type to upgrade: [block|blocks|page|pages]'
46 |                 )
47 |             ]);
48 | 
49 |         parent::configure();
50 |     }
51 | 
52 |     /**
53 |      * @inheritdoc
54 |      */
55 |     protected function execute(InputInterface $input, OutputInterface $output)
56 |     {
57 |         $cmsType = $input->getOption('type');
58 |         if (empty($cmsType)) {
59 |             $output->writeln('<info>CMS Entity type OPTION [--type] missed!</info>');
60 |             return 0;
61 |         }
62 | 
63 |         try {
64 |             switch ($cmsType) {
65 |                 case 'block':
66 |                 case 'blocks':
67 |                     $count = $this->clearCMSHistory->execute(Config::TYPE_BLOCK);
68 |                     break;
69 |                 case 'page':
70 |                 case 'pages':
71 |                     $count = $this->clearCMSHistory->execute(Config::TYPE_PAGE);
72 |                     break;
73 |                 default:
74 |                     throw new \InvalidArgumentException($cmsType . ' is incorrect CMS entity type');
75 |             }
76 |         } catch (\Exception $e) {
77 |             $output->writeln($e->getMessage());
78 |             return 0;
79 |         }
80 | 
81 |         if ($count > 0) {
82 |             $output->writeln("<info>" . __('%1 history files was deleted!', $count)->render() . "</info>");
83 |         } else {
84 |             $output->writeln('<info>All backups are actual!</info>');
85 |         }
86 |         return 0;
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/Console/Command/ImportContent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Console\Command;
 6 | 
 7 | use Overdose\CMSContent\Api\ContentImportInterface;
 8 | use Symfony\Component\Console\Command\Command;
 9 | use Symfony\Component\Console\Input\InputArgument;
10 | use Symfony\Component\Console\Input\InputInterface;
11 | use Symfony\Component\Console\Output\OutputInterface;
12 | 
13 | class ImportContent extends Command
14 | {
15 |     /**
16 |      * @var ContentImportInterface
17 |      */
18 |     private $contentImport;
19 | 
20 |     /**
21 |      * ImportContent constructor.
22 |      *
23 |      * @param ContentImportInterface $contentImport
24 |      */
25 |     public function __construct(
26 |         ContentImportInterface $contentImport
27 |     ) {
28 |         $this->contentImport = $contentImport;
29 |         parent::__construct();
30 |     }
31 | 
32 |     /**
33 |      * @inheritdoc
34 |      */
35 |     protected function configure()
36 |     {
37 |         $this->setName('od:cms:import');
38 |         $this->setDescription('Import CMS zip file');
39 |         $this->addArgument('zipfile', InputArgument::REQUIRED, __('Zip file containing CMS information')->render());
40 | 
41 |         parent::configure();
42 |     }
43 | 
44 |     /**
45 |      * @inheritdoc
46 |      */
47 |     protected function execute(InputInterface $input, OutputInterface $output)
48 |     {
49 |         $zipFile = $input->getArgument('zipfile');
50 |         if ($this->contentImport->importContentFromZipFile($zipFile, false) == 0) {
51 |             $output->writeln('Archive is empty.');
52 | 
53 |             return;
54 |         }
55 |         $output->writeln('Done.');
56 |         return 0;
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/Controller/Adminhtml/AbstractMassExport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Controller\Adminhtml;
 6 | 
 7 | use Magento\Backend\App\Response\Http\FileFactory;
 8 | use Magento\Framework\App\ResponseInterface;
 9 | use Magento\Framework\Exception\FileSystemException;
10 | use Magento\Framework\Exception\LocalizedException;
11 | use Magento\Ui\Component\MassAction\Filter;
12 | use Magento\Backend\App\Action;
13 | use Magento\Framework\Stdlib\DateTime\DateTime;
14 | use Magento\Framework\App\Filesystem\DirectoryList;
15 | use Overdose\CMSContent\Api\ContentExportInterface;
16 | use Overdose\CMSContent\Api\CmsEntityConverterManagerInterface;
17 | 
18 | abstract class AbstractMassExport extends Action
19 | {
20 |     /**
21 |      * @var Filter
22 |      */
23 |     protected $filter;
24 | 
25 |     /**
26 |      * @var ContentExportInterface
27 |      */
28 |     protected $contentExport;
29 | 
30 |     /**
31 |      * @var FileFactory
32 |      */
33 |     protected $fileFactory;
34 | 
35 |     /**
36 |      * @var DateTime
37 |      */
38 |     protected $dateTime;
39 | 
40 |     /**
41 |      * @var CmsEntityConverterManagerInterface
42 |      */
43 |     protected $cmsEntityConverterManager;
44 | 
45 |     /**
46 |      * Form file
47 |      *
48 |      * @param string $fileName
49 |      * @param array $convertedBlocks
50 |      * @param string $type
51 |      *
52 |      * @return ResponseInterface
53 |      * @throws FileSystemException|LocalizedException
54 |      */
55 |     protected function formFile(string $fileName, array $convertedBlocks, string $type): ResponseInterface
56 |     {
57 |         return $this->fileFactory->create(
58 |             $fileName,
59 |             [
60 |                 'type'  => 'filename',
61 |                 'value' => $this->returnZipFile($convertedBlocks, $fileName, $type),
62 |                 'rm'    => true,
63 |             ],
64 |             DirectoryList::VAR_DIR,
65 |             'application/zip'
66 |         );
67 |     }
68 | 
69 |     /**
70 |      * Return zip file
71 |      *
72 |      * @param array $convertedBlocks
73 |      * @param string $fileName
74 |      * @param string $type
75 |      *
76 |      * @return string
77 |      * @throws FileSystemException|LocalizedException
78 |      */
79 |     protected function returnZipFile(array $convertedBlocks, string $fileName, string $type): string
80 |     {
81 |         $fileType = (string)$this->getRequest()->getParam('type', 'json');
82 |         $isSplit  = (bool)$this->getRequest()->getParam('split', false);
83 | 
84 |         return $this->contentExport->createZipFile(
85 |             $convertedBlocks,
86 |             $type,
87 |             $fileType,
88 |             $fileName,
89 |             $isSplit
90 |         );
91 |     }
92 | }
93 | 


--------------------------------------------------------------------------------
/Controller/Adminhtml/Block/MassExport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Controller\Adminhtml\Block;
 6 | 
 7 | use Magento\Backend\App\Response\Http\FileFactory;
 8 | use Magento\Framework\App\Action\HttpPostActionInterface;
 9 | use Magento\Framework\App\ResponseInterface;
10 | use Magento\Framework\Exception\LocalizedException;
11 | use Magento\Ui\Component\MassAction\Filter;
12 | use Magento\Backend\App\Action;
13 | use Magento\Framework\Stdlib\DateTime\DateTime;
14 | use Magento\Cms\Model\ResourceModel\Block\CollectionFactory;
15 | use Overdose\CMSContent\Api\ContentExportInterface;
16 | use Overdose\CMSContent\Api\CmsEntityConverterManagerInterface;
17 | use Overdose\CMSContent\Controller\Adminhtml\AbstractMassExport;
18 | 
19 | class MassExport extends AbstractMassExport implements HttpPostActionInterface
20 | {
21 |     /**
22 |      * Authorization level of a basic admin session
23 |      *
24 |      * @see _isAllowed()
25 |      */
26 |     const ADMIN_RESOURCE = 'Overdose_CMSContent::export_block';
27 | 
28 |     /**
29 |      * @var CollectionFactory
30 |      */
31 |     private $collectionFactory;
32 | 
33 |     /**
34 |      * @param Action\Context $context
35 |      * @param Filter $filter
36 |      * @param ContentExportInterface $contentExport
37 |      * @param CollectionFactory $collectionFactory
38 |      * @param FileFactory $fileFactory
39 |      * @param DateTime $dateTime
40 |      * @param CmsEntityConverterManagerInterface $cmsEntityConverterManager
41 |      */
42 |     public function __construct(
43 |         Action\Context $context,
44 |         Filter $filter,
45 |         ContentExportInterface $contentExport,
46 |         CollectionFactory $collectionFactory,
47 |         FileFactory $fileFactory,
48 |         DateTime $dateTime,
49 |         CmsEntityConverterManagerInterface $cmsEntityConverterManager
50 |     ) {
51 |         $this->filter = $filter;
52 |         $this->collectionFactory = $collectionFactory;
53 |         $this->contentExport = $contentExport;
54 |         $this->fileFactory = $fileFactory;
55 |         $this->dateTime = $dateTime;
56 |         $this->cmsEntityConverterManager = $cmsEntityConverterManager;
57 | 
58 |         parent::__construct($context);
59 |     }
60 | 
61 |     /**
62 |      * Make mass export
63 |      *
64 |      * @return ResponseInterface
65 |      * @throws LocalizedException
66 |      */
67 |     public function execute(): ResponseInterface
68 |     {
69 |         $blocks = $this->filter->getCollection($this->collectionFactory->create())->getItems();
70 | 
71 |         $fileName = sprintf('cms_block_%s.zip', $this->dateTime->date('Ymd_His'));
72 | 
73 |         $convertedBlocks = $this->cmsEntityConverterManager
74 |             ->getConverter(CmsEntityConverterManagerInterface::BLOCK_ENTITY_CODE)
75 |             ->convertToArray($blocks);
76 | 
77 |         return $this->formFile(
78 |             $fileName,
79 |             $convertedBlocks,
80 |             CmsEntityConverterManagerInterface::BLOCK_ENTITY_CODE
81 |         );
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/Controller/Adminhtml/History/Apply.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Controller\Adminhtml\History;
  6 | 
  7 | use Laminas\Json\Json;
  8 | use Magento\Backend\App\Action;
  9 | use Magento\Backend\App\Action\Context;
 10 | use Magento\Cms\Api\BlockRepositoryInterface;
 11 | use Magento\Cms\Api\Data\BlockInterface;
 12 | use Magento\Cms\Api\PageRepositoryInterface;
 13 | use Magento\Framework\App\Action\HttpGetActionInterface;
 14 | use Magento\Framework\Controller\Result\Redirect;
 15 | use Magento\Framework\Controller\Result\RedirectFactory;
 16 | use Magento\Cms\Model\Page;
 17 | use Overdose\CMSContent\Api\ContentImportInterface;
 18 | use Overdose\CMSContent\File\FileManagerInterface;
 19 | use Overdose\CMSContent\Model\BackupManager;
 20 | 
 21 | class Apply extends Action implements HttpGetActionInterface
 22 | {
 23 |     /**
 24 |      * @var ContentImportInterface
 25 |      */
 26 |     protected $importExportInterface;
 27 | 
 28 |     /**
 29 |      * @var RedirectFactory
 30 |      */
 31 |     protected $redirectFactory;
 32 | 
 33 |     /**
 34 |      * @var PageRepositoryInterface
 35 |      */
 36 |     private $pageRepository;
 37 |     /**
 38 |      * @var BlockRepositoryInterface
 39 |      */
 40 |     private $blockRepository;
 41 |     /**
 42 |      * @var BackupManager
 43 |      */
 44 |     private $backupManager;
 45 |     /**
 46 |      * @var FileManagerInterface
 47 |      */
 48 |     private $file;
 49 |     /**
 50 |      * @var Json
 51 |      */
 52 |     private $jsonFormatter;
 53 | 
 54 |     /**
 55 |      * @param Context $context
 56 |      * @param ContentImportInterface $importExportInterface
 57 |      * @param RedirectFactory $redirectFactory
 58 |      * @param BlockRepositoryInterface $blockRepository
 59 |      * @param PageRepositoryInterface $pageRepository
 60 |      * @param BackupManager $backupManager
 61 |      * @param FileManagerInterface $file
 62 |      * @param Json $jsonFormatter
 63 |      */
 64 |     public function __construct(
 65 |         Action\Context           $context,
 66 |         ContentImportInterface   $importExportInterface,
 67 |         RedirectFactory          $redirectFactory,
 68 |         BlockRepositoryInterface $blockRepository,
 69 |         PageRepositoryInterface  $pageRepository,
 70 |         BackupManager            $backupManager,
 71 |         FileManagerInterface     $file,
 72 |         Json                     $jsonFormatter
 73 |     ) {
 74 |         $this->importExportInterface = $importExportInterface;
 75 |         $this->redirectFactory = $redirectFactory;
 76 |         $this->pageRepository = $pageRepository;
 77 |         $this->blockRepository = $blockRepository;
 78 |         $this->backupManager = $backupManager;
 79 |         $this->file = $file;
 80 |         $this->jsonFormatter = $jsonFormatter;
 81 | 
 82 |         parent::__construct($context);
 83 |     }
 84 | 
 85 |     /**
 86 |      * @return Redirect
 87 |      */
 88 |     public function execute()
 89 |     {
 90 |         $identifier = $this->getRequest()->getParam('bc_identifier');
 91 |         $itemId  = $this->getRequest()->getParam('item_id');
 92 |         $file    = $this->getRequest()->getParam('item');
 93 |         $cmsType = $this->getRequest()->getParam('bc_type');
 94 |         $storeId = $this->getRequest()->getParam('store_id');
 95 |         try {
 96 |             if (!is_null($storeId)) {
 97 |                 $path = $this->backupManager->getBackupPathByStoreId($cmsType, $identifier, (int)$storeId) . DIRECTORY_SEPARATOR . $file;
 98 |             } else {
 99 |                 $path = $this->backupManager->getBackupPath($cmsType, $identifier) . DIRECTORY_SEPARATOR . $file;
100 |             }
101 |             $backupFile = $this->file->readData($path);
102 |             $jsonBackup = $this->jsonFormatter->decode($backupFile, true);
103 |             if ($cmsType == BackupManager::TYPE_CMS_BLOCK) {
104 |                 $cmsObject = $this->blockRepository->getById($itemId);
105 |                 $cmsObject->setContent($jsonBackup['content']);
106 |                 $this->blockRepository->save($cmsObject);
107 |             } else if ($cmsType == BackupManager::TYPE_CMS_PAGE) {
108 |                 $cmsObject = $this->pageRepository->getById($itemId);
109 |                 $cmsObject->setContent($jsonBackup['content']);
110 |                 $this->pageRepository->save($cmsObject);
111 |             }
112 |             $this->messageManager->addSuccessMessage(__('Successfully changed content with backup file %1', $file));
113 |         } catch (\Exception $e) {
114 |             $this->messageManager->addErrorMessage(__('Something went wrong with saving block or page %1', $file));
115 |         }
116 |         $resultRedirect = $this->redirectFactory->create();
117 |         $resultRedirect->setUrl($this->_redirect->getRefererUrl());
118 |         return $resultRedirect;
119 |     }
120 | }
121 | 


--------------------------------------------------------------------------------
/Controller/Adminhtml/History/View.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Controller\Adminhtml\History;
 6 | 
 7 | use Magento\Backend\App\Action;
 8 | use Magento\Framework\App\Action\HttpGetActionInterface;
 9 | use Magento\Framework\Controller\ResultFactory;
10 | use Magento\Framework\Controller\ResultInterface;
11 | use Magento\Framework\View\Result\Page;
12 | 
13 | class View extends Action implements HttpGetActionInterface
14 | {
15 |     /**
16 |      * Execute view action
17 |      *
18 |      * @return ResultInterface|Page
19 |      */
20 |     public function execute()
21 |     {
22 |         $resultPage = $this->resultFactory->create(ResultFactory::TYPE_PAGE);
23 | 
24 |         $resultPage->getConfig()->getTitle()->prepend(__('Backup Preview'));
25 | 
26 |         return $resultPage;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/Controller/Adminhtml/Import/Import.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Controller\Adminhtml\Import;
 6 | 
 7 | use Magento\Backend\App\Action;
 8 | use Magento\Framework\App\Action\HttpPostActionInterface;
 9 | use Magento\Framework\Controller\Result\Redirect;
10 | use Magento\Framework\Controller\Result\RedirectFactory;
11 | use Overdose\CMSContent\Api\ContentImportInterface;
12 | 
13 | class Import extends Action implements HttpPostActionInterface
14 | {
15 |     /**
16 |      * Authorization level of a basic admin session
17 |      *
18 |      * @see _isAllowed()
19 |      */
20 |     const ADMIN_RESOURCE = 'Overdose_CMSContent::import';
21 | 
22 |     /**
23 |      * @var ContentImportInterface
24 |      */
25 |     protected $importExportInterface;
26 | 
27 |     /**
28 |      * @var RedirectFactory
29 |      */
30 |     protected $redirectFactory;
31 | 
32 |     /**
33 |      * @param Action\Context $context
34 |      * @param ContentImportInterface $importExportInterface
35 |      * @param RedirectFactory $redirectFactory
36 |      */
37 |     public function __construct(
38 |         Action\Context $context,
39 |         ContentImportInterface $importExportInterface,
40 |         RedirectFactory $redirectFactory
41 |     ) {
42 |         $this->importExportInterface = $importExportInterface;
43 |         $this->redirectFactory = $redirectFactory;
44 | 
45 |         parent::__construct($context);
46 |     }
47 | 
48 |     /**
49 |      * @return Redirect
50 |      */
51 |     public function execute(): Redirect
52 |     {
53 |         try {
54 |             $cmsMode    = $this->getRequest()->getParam('cms_import_mode');
55 |             $mediaMode  = $this->getRequest()->getParam('media_import_mode');
56 |             $upload     = $this->getRequest()->getParam('upload');
57 | 
58 |             $count = $this->importExportInterface
59 |                 ->setCmsModeOption($cmsMode)
60 |                 ->setMediaModeOption($mediaMode)
61 |                 ->importContentFromZipFile(
62 |                     $upload[0]['path'] . DIRECTORY_SEPARATOR . $upload[0]['file'],
63 |                     true
64 |                 );
65 | 
66 |             $this->messageManager->addSuccessMessage(
67 |                 __('A total of %1 item(s) have been imported/updated.', $count)
68 |             );
69 |         } catch (\Exception $e) {
70 |             $this->messageManager->addExceptionMessage($e);
71 |         }
72 | 
73 |         $resultRedirect = $this->redirectFactory->create();
74 |         return $resultRedirect->setPath('*/*/index');
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/Controller/Adminhtml/Import/Index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Controller\Adminhtml\Import;
 6 | 
 7 | use Magento\Backend\App\Action;
 8 | use Magento\Framework\Controller\ResultFactory;
 9 | use Magento\Framework\View\Result\Page;
10 | use Magento\Framework\View\Result\PageFactory;
11 | 
12 | class Index extends Action
13 | {
14 |     /**
15 |      * Authorization level of a basic admin session
16 |      *
17 |      * @see _isAllowed()
18 |      */
19 |     const ADMIN_RESOURCE = 'Overdose_CMSContent::import';
20 | 
21 |     /**
22 |      * @return Page
23 |      */
24 |     public function execute()
25 |     {
26 |         $resultPage = $this->resultFactory->create(ResultFactory::TYPE_PAGE);
27 | 
28 |         $resultPage->setActiveMenu('Overdose_CMSContent::import')
29 |             ->addBreadcrumb(__('CMS'), __('CMS'));
30 | 
31 |         $resultPage->addBreadcrumb(__('Import CMS'), __('Import CMS'));
32 | 
33 |         $resultPage->getConfig()->getTitle()->prepend(__('CMS'));
34 |         $resultPage->getConfig()->getTitle()->prepend(__('CMS Import'));
35 | 
36 |         return $resultPage;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/Controller/Adminhtml/Import/Upload.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Controller\Adminhtml\Import;
 6 | 
 7 | use Magento\Framework\App\Action\HttpPostActionInterface;
 8 | use Magento\Framework\Controller\Result\JsonFactory;
 9 | use Magento\Framework\Controller\ResultInterface;
10 | use Magento\Framework\Message\ManagerInterface;
11 | use Magento\MediaStorage\Model\File\UploaderFactory;
12 | use Overdose\CMSContent\Model\Config;
13 | 
14 | class Upload implements HttpPostActionInterface
15 | {
16 |     /**
17 |      * @var Config
18 |      */
19 |     private $config;
20 | 
21 |     /**
22 |      * @var JsonFactory
23 |      */
24 |     private $resultJsonFactory;
25 | 
26 |     /**
27 |      * @var UploaderFactory
28 |      */
29 |     private $fileUploaderFactory;
30 | 
31 |     /**
32 |      * @var ManagerInterface
33 |      */
34 |     private $messageManager;
35 | 
36 |     /**
37 |      * @param Config $config
38 |      * @param JsonFactory $resultJsonFactory
39 |      * @param UploaderFactory $fileUploaderFactory
40 |      * @param ManagerInterface $messageManager
41 |      * @codeCoverageIgnore
42 |      */
43 |     public function __construct(
44 |         Config $config,
45 |         JsonFactory $resultJsonFactory,
46 |         UploaderFactory $fileUploaderFactory,
47 |         ManagerInterface $messageManager
48 |     ) {
49 |         $this->config   = $config;
50 |         $this->resultJsonFactory = $resultJsonFactory;
51 |         $this->fileUploaderFactory = $fileUploaderFactory;
52 |         $this->messageManager = $messageManager;
53 |     }
54 | 
55 |     /**
56 |      * @return ResultInterface
57 |      */
58 |     public function execute(): ResultInterface
59 |     {
60 |         $result   = $this->upload();
61 |         $response = $this->resultJsonFactory->create();
62 |         $response->setData($result);
63 | 
64 |         return $response;
65 |     }
66 | 
67 |     /**
68 |      * Upload file
69 |      *
70 |      * @return array
71 |      */
72 |     private function upload(): array
73 |     {
74 |         $result    = [];
75 |         $uploader  = $this->fileUploaderFactory->create(['fileId' => 'upload']);
76 |         $uploader->setAllowedExtensions(['zip']);
77 |         $uploader->setAllowRenameFiles(true);
78 | 
79 |         try {
80 |             $result = $uploader->save($this->config->getBackupsDir() . DIRECTORY_SEPARATOR . 'import');
81 |         } catch (\Exception $e) {
82 |             $this->messageManager->addErrorMessage($e->getMessage());
83 |         }
84 |         return $result;
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/Controller/Adminhtml/Page/MassExport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Controller\Adminhtml\Page;
 6 | 
 7 | use Magento\Backend\App\Response\Http\FileFactory;
 8 | use Magento\Framework\App\Action\HttpPostActionInterface;
 9 | use Magento\Framework\App\ResponseInterface;
10 | use Magento\Framework\Exception\LocalizedException;
11 | use Magento\Ui\Component\MassAction\Filter;
12 | use Magento\Backend\App\Action;
13 | use Magento\Framework\Stdlib\DateTime\DateTime;
14 | use Magento\Cms\Model\ResourceModel\Page\CollectionFactory;
15 | use Overdose\CMSContent\Api\ContentExportInterface;
16 | use Overdose\CMSContent\Api\CmsEntityConverterManagerInterface;
17 | use Overdose\CMSContent\Controller\Adminhtml\AbstractMassExport;
18 | 
19 | class MassExport extends AbstractMassExport implements HttpPostActionInterface
20 | {
21 |     /**
22 |      * Authorization level of a basic admin session
23 |      *
24 |      * @see _isAllowed()
25 |      */
26 |     const ADMIN_RESOURCE = 'Overdose_CMSContent::export_page';
27 | 
28 |     /**
29 |      * @var CollectionFactory
30 |      */
31 |     private $collectionFactory;
32 | 
33 |     /**
34 |      * @param Action\Context $context
35 |      * @param Filter $filter
36 |      * @param ContentExportInterface $contentExport
37 |      * @param CollectionFactory $collectionFactory
38 |      * @param FileFactory $fileFactory
39 |      * @param DateTime $dateTime
40 |      * @param CmsEntityConverterManagerInterface $cmsEntityConverterManager
41 |      */
42 |     public function __construct(
43 |         Action\Context $context,
44 |         Filter $filter,
45 |         ContentExportInterface $contentExport,
46 |         CollectionFactory $collectionFactory,
47 |         FileFactory $fileFactory,
48 |         DateTime $dateTime,
49 |         CmsEntityConverterManagerInterface $cmsEntityConverterManager
50 |     ) {
51 |         $this->filter = $filter;
52 |         $this->collectionFactory = $collectionFactory;
53 |         $this->contentExport = $contentExport;
54 |         $this->fileFactory = $fileFactory;
55 |         $this->dateTime = $dateTime;
56 |         $this->cmsEntityConverterManager = $cmsEntityConverterManager;
57 | 
58 |         parent::__construct($context);
59 |     }
60 | 
61 |     /**
62 |      * Make mass export
63 |      *
64 |      * @return ResponseInterface
65 |      * @throws LocalizedException
66 |      */
67 |     public function execute(): ResponseInterface
68 |     {
69 |         $pages = $this->filter->getCollection($this->collectionFactory->create())->getItems();
70 | 
71 |         $fileName = sprintf('cms_page_%s.zip', $this->dateTime->date('Ymd_His'));
72 | 
73 |         $convertedPages = $this->cmsEntityConverterManager
74 |             ->getConverter(CmsEntityConverterManagerInterface::PAGE_ENTITY_CODE)
75 |             ->convertToArray($pages);
76 | 
77 |         return $this->formFile(
78 |             $fileName,
79 |             $convertedPages,
80 |             CmsEntityConverterManagerInterface::PAGE_ENTITY_CODE
81 |         );
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/Cron/DeleteBackups.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Cron;
 6 | 
 7 | use Magento\Framework\Exception\FileSystemException;
 8 | use Overdose\CMSContent\Model\Config;
 9 | use Overdose\CMSContent\Model\Service\ClearCMSHistory;
10 | 
11 | class DeleteBackups
12 | {
13 |     /**
14 |      * @var Config
15 |      */
16 |     private $config;
17 | 
18 |     /**
19 |      * @var ClearCMSHistory
20 |      */
21 |     private $clearCMSHistory;
22 | 
23 |     /**
24 |      * @param ClearCMSHistory $clearCMSHistory
25 |      * @param Config $config
26 |      */
27 |     public function __construct(
28 |         ClearCMSHistory $clearCMSHistory,
29 |         Config $config
30 |     ) {
31 |         $this->clearCMSHistory = $clearCMSHistory;
32 |         $this->config = $config;
33 |     }
34 | 
35 |     /**
36 |      * Process getting and deleting old CMS files
37 |      *
38 |      * @return void
39 |      * @throws FileSystemException
40 |      */
41 |     public function execute(): void
42 |     {
43 |         if ($this->config->isCronEnabled()) {
44 |             return;
45 |         }
46 |         $this->clearCMSHistory->execute(Config::TYPE_BLOCK);
47 |         $this->clearCMSHistory->execute(Config::TYPE_PAGE);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/Exception/InvalidXmlImportFilesException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Exception;
 6 | 
 7 | use Magento\Framework\Exception\LocalizedException;
 8 | 
 9 | class InvalidXmlImportFilesException extends LocalizedException
10 | {
11 | 
12 | }
13 | 


--------------------------------------------------------------------------------
/File/FileManager.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\File;
  6 | 
  7 | use Magento\Framework\App\Filesystem\DirectoryList;
  8 | use Magento\Framework\Exception\FileSystemException;
  9 | use Psr\Log\LoggerInterface;
 10 | use Magento\Framework\Filesystem\Io\File;
 11 | use Magento\Framework\Filesystem;
 12 | 
 13 | class FileManager implements FileManagerInterface
 14 | {
 15 |     /**
 16 |      * @var File
 17 |      */
 18 |     private $fileIo;
 19 | 
 20 |     /**
 21 |      * @var Filesystem
 22 |      */
 23 |     private $filesystem;
 24 | 
 25 |     /**
 26 |      * @var LoggerInterface
 27 |      */
 28 |     private $logger;
 29 | 
 30 |     /**
 31 |      * FileManager constructor.
 32 |      *
 33 |      * @param File $fileIo
 34 |      * @param Filesystem $filesystem
 35 |      * @param LoggerInterface $logger
 36 |      */
 37 |     public function __construct(
 38 |         File $fileIo,
 39 |         Filesystem $filesystem,
 40 |         LoggerInterface $logger
 41 |     ) {
 42 |         $this->fileIo = $fileIo;
 43 |         $this->filesystem = $filesystem;
 44 |         $this->logger = $logger;
 45 |     }
 46 | 
 47 |     /**
 48 |      * @inheritDoc
 49 |      */
 50 |     public function writeData(
 51 |         string $path,
 52 |         string $fileName,
 53 |         string $content,
 54 |         string $fileExtension = self::FILE_EXTENSION
 55 |     ): FileManagerInterface {
 56 |         if (!$path || !$fileName) {
 57 |             return $this;
 58 |         }
 59 | 
 60 |         try {
 61 |             $path = $this->getFolder($path);
 62 |             $this->fileIo->open(['path' => $path]);
 63 |             $this->fileIo->write($fileName . $fileExtension, $content, 0666);
 64 |         } catch (\Exception $e) {
 65 |             $this->logger->critical(__('Something went wrong while saving file'));
 66 |         }
 67 |         return $this;
 68 |     }
 69 | 
 70 |     /**
 71 |      * @inheritDoc
 72 |      */
 73 |     public function readData($filename)
 74 |     {
 75 |         return $this->fileIo->read($filename);
 76 |     }
 77 | 
 78 |     /**
 79 |      * Get folder
 80 |      *
 81 |      * @param string $path
 82 |      *
 83 |      * @return string;
 84 |      */
 85 |     public function getFolder(string $path): string
 86 |     {
 87 |         try {
 88 |             $this->fileIo->checkAndCreateFolder($path, 0775);
 89 | 
 90 |             return $path;
 91 |         } catch (\Exception $e) {
 92 |             $this->logger->critical(__('Something went wrong while saving file'));
 93 | 
 94 |             return '';
 95 |         }
 96 |     }
 97 | 
 98 |     /**
 99 |      * Get media file path
100 |      *
101 |      * @param string $mediaFile
102 |      * @param bool $write = false
103 |      *
104 |      * @return string
105 |      * @throws FileSystemException
106 |      */
107 |     public function getMediaPath(string $mediaFile, bool $write = false): ?string
108 |     {
109 |         if ($write) {
110 |             $mediaDir = $this->filesystem->getDirectoryWrite(DirectoryList::MEDIA);
111 |         } else {
112 |             $mediaDir = $this->filesystem->getDirectoryRead(DirectoryList::MEDIA);
113 |         }
114 |         return $mediaDir->getAbsolutePath($mediaFile);
115 |     }
116 | }
117 | 


--------------------------------------------------------------------------------
/File/FileManagerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\File;
 6 | 
 7 | interface FileManagerInterface
 8 | {
 9 |     const FILE_EXTENSION = '.html';
10 | 
11 |     /**
12 |      * Write prepared content to file
13 |      *
14 |      * @param string $path
15 |      * @param string $fileName
16 |      * @param string $content
17 |      * @param string $fileExtension
18 |      *
19 |      * @return FileManagerInterface
20 |      */
21 |     public function writeData(
22 |         string $path,
23 |         string $fileName,
24 |         string $content,
25 |         string $fileExtension = self::FILE_EXTENSION
26 |     ): FileManagerInterface;
27 | 
28 |     /**
29 |      * Read content from file
30 |      *
31 |      * @param $filename
32 |      *
33 |      * @return mixed
34 |      */
35 |     public function readData($filename);
36 | }
37 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.


--------------------------------------------------------------------------------
/Model/Config.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Model;
  6 | 
  7 | use Magento\Framework\App\Config\ScopeConfigInterface;
  8 | use Magento\Framework\App\Filesystem\DirectoryList;
  9 | use Magento\Store\Model\ScopeInterface;
 10 | 
 11 | class Config
 12 | {
 13 |     /**#@+
 14 |      * CMSContent Objects Types
 15 |      */
 16 |     public const TYPE_PAGE = 'pages';
 17 |     public const TYPE_BLOCK = 'blocks';
 18 |     /**#@-*/
 19 | 
 20 |     /**#@+
 21 |      * Export folders
 22 |      */
 23 |     const EXPORT_PATH = 'export/export';
 24 |     const EXTRACT_PATH = 'export/extract';
 25 |     /**#@-*/
 26 | 
 27 |     public const CMS_DIR = 'cms';
 28 |     public const HISTORY_DIR = 'history';
 29 | 
 30 |     public const PERIOD = 'by_periods';
 31 |     public const OLDER_THAN = 'older_than';
 32 | 
 33 |     public const DAY = 60 * 60 * 24;
 34 |     public const WEEK = 60 * 60 * 24 * 7;
 35 |     public const MONTH = 60 * 60 * 24 * 30;
 36 |     public const YEAR = 60 * 60 * 24 * 365;
 37 | 
 38 |     const XML_PATH_IS_ENABLED = 'cms_content/general/enabled';
 39 | 
 40 |     /**
 41 |      * Delete section
 42 |      */
 43 |     const XML_PATH_IS_CRON_ENABLED = 'cms_content/backups/delete/cron_enabled';
 44 |     const XML_PATH_DELETE_METHOD_TYPE = 'cms_content/backups/delete/method';
 45 |     const XML_PATH_OLDER_THAN_PERIOD_TYPE = 'cms_content/backups/delete/period';
 46 |     const XML_PATH_OLDER_THAN_PERIOD_NUMBER = 'cms_content/backups/delete/number';
 47 |     const CRON_STRING_PATH = 'crontab/default/jobs/cms_content_delete_backups/schedule/cron_expr';
 48 |     const CRON_ARRAY_PATH_TIME_VALUE = 'groups/backups/groups/cron_run_settings/fields/time/value';
 49 |     const CRON_ARRAY_PATH_FREQUENCY_VALUE = 'groups/backups/groups/cron_run_settings/fields/frequency/value';
 50 | 
 51 |     /**
 52 |      * Logs section
 53 |      */
 54 |     const XML_PATH_LOGS = 'cms_content/logs/logs_enabled';
 55 | 
 56 |     /**
 57 |      * @var ScopeConfigInterface
 58 |      */
 59 |     private $scopeConfig;
 60 | 
 61 |     /**
 62 |      * @var DirectoryList
 63 |      */
 64 |     private $directoryList;
 65 | 
 66 |     /**
 67 |      * @param ScopeConfigInterface $scopeConfig
 68 |      * @param DirectoryList $directoryList
 69 |      */
 70 |     public function __construct(
 71 |         ScopeConfigInterface $scopeConfig,
 72 |         DirectoryList $directoryList
 73 |     ) {
 74 |         $this->scopeConfig = $scopeConfig;
 75 |         $this->directoryList = $directoryList;
 76 |     }
 77 | 
 78 |     /**
 79 |      * Check is functionality enabled
 80 |      *
 81 |      * @return bool
 82 |      */
 83 |     public function isEnabled(): bool
 84 |     {
 85 |         return (bool)$this->scopeConfig->getValue(self::XML_PATH_IS_ENABLED, ScopeInterface::SCOPE_WEBSITE);
 86 |     }
 87 | 
 88 |     /**
 89 |      * Check is delete by cron enabled
 90 |      *
 91 |      * @return bool
 92 |      */
 93 |     public function isCronEnabled(): bool
 94 |     {
 95 |         return (bool)$this->scopeConfig->getValue(self::XML_PATH_IS_CRON_ENABLED, ScopeInterface::SCOPE_STORE);
 96 |     }
 97 | 
 98 |     /**
 99 |      * Get method type
100 |      *
101 |      * @return string
102 |      */
103 |     public function getMethodType(): string
104 |     {
105 |         if (!$result = $this->scopeConfig->getValue(self::XML_PATH_DELETE_METHOD_TYPE, ScopeInterface::SCOPE_STORE)) {
106 |             return self::PERIOD;
107 |         }
108 |         return $result;
109 |     }
110 | 
111 |     /**
112 |      * Get period type
113 |      *
114 |      * @return int
115 |      */
116 |     public function getPeriodType(): int
117 |     {
118 |         if (!$result = $this->scopeConfig->getValue(
119 |             self::XML_PATH_OLDER_THAN_PERIOD_TYPE,
120 |             ScopeInterface::SCOPE_STORE
121 |         )) {
122 |             return self::MONTH;
123 |         }
124 |         return (int)$result;
125 |     }
126 | 
127 |     /**
128 |      * Get period number
129 |      *
130 |      * @return int
131 |      */
132 |     public function getPeriodNumber(): int
133 |     {
134 |         if (!$result = $this->scopeConfig->getValue(
135 |             self::XML_PATH_OLDER_THAN_PERIOD_NUMBER, ScopeInterface::SCOPE_STORE
136 |         )) {
137 |             return 5;
138 |         }
139 |         return (int)$result;
140 |     }
141 | 
142 |     /**
143 |      * @return bool
144 |      */
145 |     public function isLogsEnabled(): bool
146 |     {
147 |         return (bool)$this->scopeConfig->getValue(self::XML_PATH_LOGS, ScopeInterface::SCOPE_STORE);
148 |     }
149 | 
150 |     /**
151 |      * Get full path to directory with backups
152 |      *
153 |      * @return string
154 |      */
155 |     public function getBackupsDir(): string
156 |     {
157 |         try {
158 |             return $this->directoryList->getPath(DirectoryList::VAR_DIR) . DIRECTORY_SEPARATOR . self::CMS_DIR;
159 |         } catch (\Exception $e) {
160 |             return '';
161 |         }
162 |     }
163 | 
164 |     /**
165 |      * Form export path
166 |      *
167 |      * @return string
168 |      */
169 |     public function getExportPath(): string
170 |     {
171 |         try {
172 |             return $this->directoryList->getPath(DirectoryList::VAR_DIR)
173 |                 . DIRECTORY_SEPARATOR
174 |                 . self::CMS_DIR
175 |                 . DIRECTORY_SEPARATOR
176 |                 . self::EXPORT_PATH;
177 |         } catch (\Exception $e) {
178 |             return '';
179 |         }
180 |     }
181 | 
182 |     /**
183 |      * Get Extract Path
184 |      *
185 |      * @return string
186 |      */
187 |     public function getExtractPath(): string
188 |     {
189 |         try {
190 |             return $this->directoryList->getPath(DirectoryList::VAR_DIR)
191 |                 . DIRECTORY_SEPARATOR
192 |                 . self::CMS_DIR
193 |                 . DIRECTORY_SEPARATOR
194 |                 . self::EXTRACT_PATH;
195 |         } catch (\Exception $e) {
196 |             return '';
197 |         }
198 |     }
199 | }
200 | 


--------------------------------------------------------------------------------
/Model/Config/App/FileResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Overdose\CMSContent\Model\Config\App;
 4 | 
 5 | use Magento\Framework\App\Filesystem\DirectoryList;
 6 | use Magento\Framework\Config\FileIteratorFactory;
 7 | use Magento\Framework\Config\FileResolverInterface;
 8 | use Magento\Framework\Filesystem;
 9 | use Overdose\CMSContent\Model\Dir\Reader;
10 | 
11 | class FileResolver implements FileResolverInterface
12 | {
13 |     /**
14 |      * Module configuration file reader
15 |      *
16 |      * @var Reader
17 |      */
18 |     protected $moduleReader;
19 | 
20 |     /**
21 |      * File iterator factory
22 |      *
23 |      * @var FileIteratorFactory
24 |      */
25 |     protected $iteratorFactory;
26 | 
27 |     /**
28 |      * Filesystem
29 |      *
30 |      * @var Filesystem
31 |      */
32 |     protected $filesystem;
33 | 
34 |     /**
35 |      * @param Reader $moduleReader
36 |      * @param Filesystem $filesystem
37 |      * @param FileIteratorFactory $iteratorFactory
38 |      */
39 |     public function __construct(
40 |         Reader $moduleReader,
41 |         Filesystem $filesystem,
42 |         FileIteratorFactory $iteratorFactory
43 |     ) {
44 |         $this->iteratorFactory = $iteratorFactory;
45 |         $this->filesystem = $filesystem;
46 |         $this->moduleReader = $moduleReader;
47 |     }
48 | 
49 |     /**
50 |      * {@inheritdoc}
51 |      */
52 |     public function get($filename, $scope)
53 |     {
54 |         switch ($scope) {
55 |             case 'primary':
56 |                 $directory = $this->filesystem->getDirectoryRead(DirectoryList::CONFIG);
57 |                 $absolutePaths = [];
58 |                 foreach ($directory->search('{' . $filename . ',*/' . $filename . '}') as $path) {
59 |                     $absolutePaths[] = $directory->getAbsolutePath($path);
60 |                 }
61 |                 $iterator = $this->iteratorFactory->create($absolutePaths);
62 |                 break;
63 |             case 'global':
64 |                 $iterator = $this->moduleReader->getConfigurationFiles($filename);
65 |                 break;
66 |             default:
67 |                 $iterator = $this->moduleReader->getConfigurationFiles($scope . '/' . $filename);
68 |                 break;
69 |         }
70 |         return $iterator;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/Model/Config/Block/Converter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Config\Block;
 6 | 
 7 | use Overdose\CMSContent\Model\Config\ConverterAbstract;
 8 | 
 9 | class Converter extends ConverterAbstract
10 | {
11 |     protected $itemsNode = 'cms_blocks';
12 |     protected $childNode = 'cms_block';
13 | }
14 | 


--------------------------------------------------------------------------------
/Model/Config/Block/Reader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Config\Block;
 6 | 
 7 | use Overdose\CMSContent\Model\Config\ReaderAbstract;
 8 | 
 9 | class Reader extends ReaderAbstract
10 | {
11 |     const FILE_NAME = 'cms_block_data.xml';
12 | 
13 |     /**
14 |      * @inheridoc
15 |      */
16 |     protected $_idAttributes = [
17 |         '/config/cms_blocks' => '',
18 |         '/config/cms_blocks/cms_block' => 'identifier',
19 |         '/config/cms_blocks/cms_block/attribute' => 'code',
20 |     ];
21 | }
22 | 


--------------------------------------------------------------------------------
/Model/Config/Block/SchemaLocator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Config\Block;
 6 | 
 7 | use Overdose\CMSContent\Model\Config\SchemaLocatorAbstract;
 8 | 
 9 | class SchemaLocator extends SchemaLocatorAbstract
10 | {
11 |     protected $schemaFile = 'cms_block_data.xsd';
12 | }
13 | 


--------------------------------------------------------------------------------
/Model/Config/ConverterAbstract.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Overdose\CMSContent\Model\Config;
 4 | 
 5 | use Magento\Framework\Config\ConverterInterface;
 6 | 
 7 | abstract class ConverterAbstract implements ConverterInterface
 8 | {
 9 |     protected $itemsNode = '';
10 |     protected $childNode = '';
11 | 
12 |     /**
13 |      * Converting data to array type
14 |      *
15 |      * @param mixed $source
16 |      *
17 |      * @return array
18 |      * @throws \InvalidArgumentException
19 |      * @SuppressWarnings(PHPMD.CyclomaticComplexity)
20 |      */
21 |     public function convert($source)
22 |     {
23 |         $output = [];
24 |         if (!$source instanceof \DOMDocument) {
25 |             return $output;
26 |         }
27 | 
28 |         /** @var \DOMNodeList $items */
29 |         $items = $source->getElementsByTagName($this->itemsNode);
30 | 
31 |         /** @var \DOMElement $item */
32 |         foreach ($items as $item) {
33 |             $resultArray = [];
34 | 
35 |             /** @var \DOMNodeList $children */
36 |             $children = $item->getElementsByTagName($this->childNode);
37 |             /** @var \DOMElement $child */
38 |             foreach ($children as $child) {
39 |                 $childData = [];
40 |                 if (!$identifier = $child->getAttribute('identifier')) {
41 |                     throw new \InvalidArgumentException(
42 |                         __('Attribute "identifier" of "%1" does not exist', $this->childNode)
43 |                     );
44 |                 }
45 | 
46 |                 $childData['identifier'] = $identifier;
47 | 
48 |                 /** @var \DOMNodeList $cmsAttributes */
49 |                 $cmsAttributes = $child->getElementsByTagName('attribute');
50 |                 /** \DOMElement $cmsAttribute */
51 |                 foreach ($cmsAttributes as $cmsAttribute) {
52 |                     $childData[$cmsAttribute->getAttribute('code')] = $cmsAttribute->textContent;
53 |                 }
54 | 
55 |                 $storeIdsString = empty($childData['store_ids'])
56 |                     ? '0' : str_replace(',', '_', $childData['store_ids']);
57 |                 $childIndex = $identifier . '_' . $storeIdsString;
58 |                 $resultArray[$childIndex] = $childData;
59 |             }
60 | 
61 |             //IF need array wrapper cms_blocks/cms_pages use $output[$this->itemsNode] = $resultArray;
62 |             $output = array_merge($output, $resultArray);
63 |         }
64 | 
65 |         return $output;
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/Model/Config/Cron/SaveValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Config\Cron;
 6 | 
 7 | use Magento\Cron\Model\Config\Source\Frequency;
 8 | use Magento\Framework\App\Cache\TypeListInterface;
 9 | use Magento\Framework\App\Config\ConfigResource\ConfigInterface;
10 | use Magento\Framework\App\Config\ScopeConfigInterface;
11 | use Magento\Framework\App\Config\Value;
12 | use Magento\Framework\Data\Collection\AbstractDb;
13 | use Magento\Framework\Model\Context;
14 | use Magento\Framework\Model\ResourceModel\AbstractResource;
15 | use Magento\Framework\Registry;
16 | use Overdose\CMSContent\Model\Config;
17 | 
18 | class SaveValue extends Value
19 | {
20 |     /**
21 |      * @var ConfigInterface
22 |      */
23 |     private $configInterface;
24 | 
25 |     /**
26 |      * @param Context $context
27 |      * @param Registry $registry
28 |      * @param ScopeConfigInterface $config
29 |      * @param TypeListInterface $cacheTypeList
30 |      * @param AbstractResource|null $resource
31 |      * @param AbstractDb|null $resourceCollection
32 |      * @param ConfigInterface $configInterface
33 |      * @param array $data
34 |      */
35 |     public function __construct(
36 |         Context $context,
37 |         Registry $registry,
38 |         ScopeConfigInterface $config,
39 |         TypeListInterface $cacheTypeList,
40 |         AbstractResource $resource = null,
41 |         AbstractDb $resourceCollection = null,
42 |         ConfigInterface $configInterface,
43 |         array $data = []
44 |     ) {
45 |         parent::__construct($context, $registry, $config, $cacheTypeList, $resource, $resourceCollection, $data);
46 |         $this->configInterface = $configInterface;
47 |     }
48 | 
49 |     /**
50 |      * @return SaveValue
51 |      * @throws \Exception
52 |      */
53 |     public function afterSave(): SaveValue
54 |     {
55 |         $time = $this->getData(Config::CRON_ARRAY_PATH_TIME_VALUE);
56 |         $frequency = $this->getData(Config::CRON_ARRAY_PATH_FREQUENCY_VALUE);
57 | 
58 |         $cronExprArray = [
59 |             (int)$time[1], //Minute
60 |             (int)$time[0], //Hour
61 |             $frequency == Frequency::CRON_MONTHLY ? '1' : '*', //Day of the Month
62 |             '*', //Month of the Year
63 |             $frequency == Frequency::CRON_WEEKLY ? '1' : '*', //Day of the Week
64 |         ];
65 | 
66 |         $cronExprString = implode(' ', $cronExprArray);
67 | 
68 |         try {
69 |             $this->configInterface->saveConfig(
70 |                 Config::CRON_STRING_PATH,
71 |                 $cronExprString,
72 |                 $this->getScope(),
73 |                 $this->getScopeId()
74 |             );
75 |         } catch (\Exception $e) {
76 |             throw new \Exception(__('We can\'t save the cron expression.'));
77 |         }
78 | 
79 |         return parent::afterSave();
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/Model/Config/Page/Converter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Overdose\CMSContent\Model\Config\Page;
 4 | 
 5 | class Converter extends \Overdose\CMSContent\Model\Config\ConverterAbstract
 6 | {
 7 |     protected $itemsNode = 'cms_pages';
 8 |     protected $childNode = 'cms_page';
 9 | }
10 | 


--------------------------------------------------------------------------------
/Model/Config/Page/Reader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Config\Page;
 6 | 
 7 | use Overdose\CMSContent\Model\Config\ReaderAbstract;
 8 | 
 9 | class Reader extends ReaderAbstract
10 | {
11 |     const FILE_NAME = 'cms_page_data.xml';
12 | 
13 |     /**
14 |      * @inheridoc
15 |      */
16 |     protected $_idAttributes = [
17 |         '/config/cms_pages' => '',
18 |         '/config/cms_pages/cms_page' => 'identifier',
19 |         '/config/cms_pages/cms_page/attribute' => 'code',
20 |     ];
21 | }
22 | 


--------------------------------------------------------------------------------
/Model/Config/Page/SchemaLocator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Overdose\CMSContent\Model\Config\Page;
 4 | 
 5 | use Overdose\CMSContent\Model\Config\SchemaLocatorAbstract;
 6 | 
 7 | class SchemaLocator extends SchemaLocatorAbstract
 8 | {
 9 |     protected $schemaFile = 'cms_page_data.xsd';
10 | }
11 | 


--------------------------------------------------------------------------------
/Model/Config/ReaderAbstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Model\Config;
  6 | 
  7 | use Magento\Framework\Config\ConverterInterface;
  8 | use Magento\Framework\Config\SchemaLocatorInterface;
  9 | use Magento\Framework\Config\ValidationStateInterface;
 10 | use Magento\Framework\Config\Reader\Filesystem;
 11 | use Magento\Framework\Exception\LocalizedException;
 12 | use Overdose\CMSContent\Api\Data\ContentVersionInterface;
 13 | use Overdose\CMSContent\Exception\InvalidXmlImportFilesException;
 14 | use Overdose\CMSContent\Model\Config\App\FileResolver;
 15 | use Overdose\CMSContent\Model\Config\Block\Reader as BlockReader;
 16 | use Psr\Log\LoggerInterface;
 17 | 
 18 | abstract class ReaderAbstract extends Filesystem
 19 | {
 20 |     const SCOPE_GLOBAL = 'global';
 21 |     const SCOPE_PRIMARY = 'primary';
 22 |     const FILE_NAME = '';
 23 |     const OD_CONFIG_DIR_NAME = 'od_cms';
 24 | 
 25 |     /**
 26 |      * @var array
 27 |      */
 28 |     protected $_idAttributes = [];
 29 | 
 30 |     /**
 31 |      * @var LoggerInterface
 32 |      */
 33 |     protected $logger;
 34 | 
 35 |     /**
 36 |      * Reader constructor.
 37 |      *
 38 |      * @param FileResolver $fileResolver
 39 |      * @param ConverterInterface $converter
 40 |      * @param SchemaLocatorInterface $schemaLocator
 41 |      * @param ValidationStateInterface $validationState
 42 |      * @param array $idAttributes
 43 |      * @param string $domDocumentClass
 44 |      * @param string $defaultScope
 45 |      * @param LoggerInterface $logger
 46 |      */
 47 |     public function __construct(
 48 |         FileResolver $fileResolver,
 49 |         ConverterInterface $converter,
 50 |         SchemaLocatorInterface $schemaLocator,
 51 |         ValidationStateInterface $validationState,
 52 |         LoggerInterface $logger,
 53 |         $idAttributes = [],
 54 |         $domDocumentClass = \Magento\Framework\Config\Dom::class,
 55 |         $defaultScope = 'primary'
 56 |     ) {
 57 |         $this->logger = $logger;
 58 | 
 59 |         parent::__construct(
 60 |             $fileResolver,
 61 |             $converter,
 62 |             $schemaLocator,
 63 |             $validationState,
 64 |             static::FILE_NAME,
 65 |             $idAttributes,
 66 |             $domDocumentClass,
 67 |             $defaultScope
 68 |         );
 69 |     }
 70 | 
 71 |     /**
 72 |      * Load configuration for primary and global scopes
 73 |      *
 74 |      * @param null $scope
 75 |      * @return array
 76 |      * @throws LocalizedException
 77 |      */
 78 |     public function read($scope = null)
 79 |     {
 80 |         $fileListGlobal = $this->_fileResolver->get($this->_fileName, self::SCOPE_GLOBAL);
 81 |         $fileListGlobal = count($fileListGlobal) ? $fileListGlobal->toArray() : [];
 82 |         $fileListPrimary = $this->_fileResolver->get($this->_fileName, self::SCOPE_PRIMARY);
 83 |         $fileListPrimary = count($fileListPrimary) ? $fileListPrimary->toArray() : [];
 84 | 
 85 |         $configGlobal = $this->_readFiles($fileListGlobal);
 86 |         $configPrimary = $this->_readFiles($fileListPrimary);
 87 | 
 88 |         if ($duplicateItems = array_intersect_key($configGlobal, $configPrimary)) {
 89 |             $listOfImportFiles = array_merge(array_keys($fileListGlobal), array_keys($fileListPrimary));
 90 |             $this->handleDuplicationError($duplicateItems, $listOfImportFiles);
 91 |         }
 92 | 
 93 |         return array_merge($configGlobal, $configPrimary);
 94 |     }
 95 | 
 96 |     /**
 97 |      * @param string $file
 98 |      * @return array
 99 |      * @throws LocalizedException
100 |      */
101 |     public function readFromFile(string $file)
102 |     {
103 |         return $this->_readFiles([$file => file_get_contents($file)]);
104 |     }
105 | 
106 |     /**
107 |      * @param array $duplicateItems
108 |      * @param array $listOfImportFiles
109 |      * @return mixed
110 |      * @throws InvalidXmlImportFilesException
111 |      */
112 |     private function handleDuplicationError(array $duplicateItems, array $listOfImportFiles)
113 |     {
114 |         $entityName = $this->_fileName === BlockReader::FILE_NAME ? 'block' : 'page';
115 |         $duplicates = '';
116 |         foreach ($duplicateItems as $item) {
117 |             $duplicates .= sprintf(
118 |                 "%s identifier \"%s\" for the store id - %s, ",
119 |                 $entityName,
120 |                 $item[ContentVersionInterface::IDENTIFIER],
121 |                 $item[ContentVersionInterface::STORE_IDS] ?: '0'
122 |             );
123 |         }
124 |         $errorMessage = __(
125 |             "CMS import failed. You have duplicate %1s. "
126 |             . 'Please check your import files. List of duplicates - %2.',
127 |             $entityName,
128 |             $duplicates
129 |         );
130 |         $this->logger->critical(__(
131 |             $errorMessage . "\n List of import files for the duplication check - %1",
132 |             implode(', ', $listOfImportFiles)
133 |         ));
134 | 
135 |         throw new InvalidXmlImportFilesException($errorMessage);
136 |     }
137 | }
138 | 


--------------------------------------------------------------------------------
/Model/Config/SchemaLocatorAbstract.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Overdose\CMSContent\Model\Config;
 4 | 
 5 | use Magento\Framework\Module\Dir;
 6 | use Magento\Framework\Module\Dir\Reader;
 7 | use Magento\Framework\Config\SchemaLocatorInterface;
 8 | 
 9 | abstract class SchemaLocatorAbstract implements SchemaLocatorInterface
10 | {
11 |     protected $schemaFile = '';
12 | 
13 |     /**
14 |      * Path to corresponding XSD file with validation rules for merged config
15 |      *
16 |      * @var string
17 |      */
18 |     private $schema;
19 | 
20 |     /**
21 |      * Path to corresponding XSD file with validation rules for separate config files
22 |      *
23 |      * @var string
24 |      */
25 |     private $perFileSchema;
26 | 
27 |     /**
28 |      * SchemaLocator constructor.
29 |      *
30 |      * @param Reader $moduleReader
31 |      */
32 |     public function __construct(
33 |         Reader $moduleReader
34 |     ) {
35 |         $this->schema = $moduleReader->getModuleDir(Dir::MODULE_ETC_DIR, 'Overdose_CMSContent')
36 |             . DIRECTORY_SEPARATOR . $this->schemaFile;
37 |         $this->perFileSchema = $moduleReader->getModuleDir(Dir::MODULE_ETC_DIR, 'Overdose_CMSContent')
38 |             . DIRECTORY_SEPARATOR . $this->schemaFile;
39 |     }
40 | 
41 |     /**
42 |      * @inheritDoc
43 |      */
44 |     public function getSchema(): ?string
45 |     {
46 |         return $this->schema;
47 |     }
48 | 
49 |     /**
50 |      * @inheritDoc
51 |      */
52 |     public function getPerFileSchema(): ?string
53 |     {
54 |         return $this->perFileSchema;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/Model/Content/Converter/AbstractConverter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Content\Converter;
 6 | 
 7 | use Magento\Cms\Api\BlockRepositoryInterface;
 8 | use Magento\Framework\Exception\LocalizedException;
 9 | use Magento\Framework\Exception\NoSuchEntityException;
10 | use Magento\Store\Api\StoreRepositoryInterface;
11 | 
12 | abstract class AbstractConverter
13 | {
14 |     /**
15 |      * @var BlockRepositoryInterface
16 |      */
17 |     protected $blockRepositoryInterface;
18 | 
19 |     /**
20 |      * @var StoreRepositoryInterface
21 |      */
22 |     protected $storeRepositoryInterface;
23 | 
24 |     /**
25 |      * @param StoreRepositoryInterface $storeRepositoryInterface
26 |      * @param BlockRepositoryInterface $blockRepositoryInterface
27 |      */
28 |     public function __construct(
29 |         StoreRepositoryInterface $storeRepositoryInterface,
30 |         BlockRepositoryInterface $blockRepositoryInterface
31 |     ) {
32 |         $this->storeRepositoryInterface = $storeRepositoryInterface;
33 |         $this->blockRepositoryInterface = $blockRepositoryInterface;
34 |     }
35 | 
36 |     /**
37 |      * Get media attachments from content
38 |      *
39 |      * @param $content
40 |      *
41 |      * @return array
42 |      */
43 |     protected function getMediaAttachments($content): array
44 |     {
45 |         $result = [];
46 |         if (preg_match_all('/\{\{media.+?url\s*=\s*("|&quot;)(.+?)("|&quot;).*?\}\}/', $content, $matches)) {
47 |             $result += $matches[2];
48 |         }
49 | 
50 |         if (preg_match_all('/{{media.+?url\s*=\s*(?!"|&quot;)(.+?)}}/', $content, $matches)) {
51 |             $result += $matches[1];
52 |         }
53 | 
54 |         return $result;
55 |     }
56 | 
57 |     /**
58 |      * @param string $content
59 |      *
60 |      * @return array
61 |      * @throws LocalizedException
62 |      */
63 |     protected function saveBlockByIdent(string $content): array
64 |     {
65 |         $references = [];
66 | 
67 |         $pattern = '/{{widget.+?block_id\s*=\s*("|&quot;)(\d+?)("|&quot;).*?}}/';
68 | 
69 |         if (preg_match_all($pattern, $content, $matches)) {
70 |             foreach ($matches[2] as $blockId) {
71 |                 $block = $this->blockRepositoryInterface->getById($blockId);
72 |                 $references[$blockId] = $block->getIdentifier();
73 |             }
74 |         }
75 | 
76 |         return $references;
77 |     }
78 | 
79 |     /**
80 |      * Get store codes
81 |      *
82 |      * @param array $storeIds
83 |      *
84 |      * @return array
85 |      * @throws NoSuchEntityException
86 |      */
87 |     public function getStoreCodes(array $storeIds): array
88 |     {
89 |         $return = [];
90 |         foreach ($storeIds as $storeId) {
91 |             $return[] = $this->storeRepositoryInterface->getById($storeId)->getCode();
92 |         }
93 |         return $return;
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/Model/Content/Converter/Block/Converter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Content\Converter\Block;
 6 | 
 7 | use Magento\Cms\Api\Data\BlockInterface;
 8 | use Magento\Framework\Exception\LocalizedException;
 9 | use Magento\Framework\Exception\NoSuchEntityException;
10 | use Overdose\CMSContent\Model\Content\Converter\AbstractConverter;
11 | use Overdose\CMSContent\Model\Content\Converter\CmsEntityConverterInterface;
12 | 
13 | class Converter extends AbstractConverter implements CmsEntityConverterInterface
14 | {
15 |     /**
16 |      * @inheritdoc
17 |      */
18 |     public function convertToArray(array $cmsEntities): array
19 |     {
20 |         $blocks = [];
21 |         $media  = [];
22 | 
23 |         foreach ($cmsEntities as $cmsEntity) {
24 |             $blockInfo = $this->convertBlockToArray($cmsEntity);
25 |             $blocks[$this->getBlockKey($cmsEntity)] = $blockInfo;
26 |             $media = array_merge($media, $blockInfo['media']);
27 |         }
28 | 
29 |         return [
30 |             self::BLOCK_ENTITY_CODE => $blocks,
31 |             'media' => $media,
32 |         ];
33 |     }
34 | 
35 |     /**
36 |      * Convert CMS block to array
37 |      *
38 |      * @param BlockInterface $blockInterface
39 |      *
40 |      * @return array
41 |      * @throws LocalizedException
42 |      */
43 |     private function convertBlockToArray(BlockInterface $blockInterface): array
44 |     {
45 |         // Extract attachments
46 |         $media = $this->getMediaAttachments($blockInterface->getContent());
47 | 
48 |         return [
49 |             'cms' => [
50 |                 BlockInterface::IDENTIFIER => $blockInterface->getIdentifier(),
51 |                 BlockInterface::TITLE => $blockInterface->getTitle(),
52 |                 BlockInterface::CONTENT => $blockInterface->getContent(),
53 |                 BlockInterface::IS_ACTIVE => (string)$blockInterface->isActive(),
54 |             ],
55 |             'stores' => $this->getStoreCodes($blockInterface->getStores()),
56 |             'media' => $media,
57 |             'block_references' => $this->saveBlockByIdent($blockInterface->getContent())
58 |         ];
59 |     }
60 | 
61 |     /**
62 |      * Get block unique key
63 |      *
64 |      * @param BlockInterface $blockInterface
65 |      *
66 |      * @return string
67 |      * @throws NoSuchEntityException
68 |      */
69 |     private function getBlockKey(BlockInterface $blockInterface): string
70 |     {
71 |         $keys = $this->getStoreCodes($blockInterface->getStores());
72 |         $keys[] = $blockInterface->getIdentifier();
73 | 
74 |         return implode(':', $keys);
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/Model/Content/Converter/CmsEntityConverterInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Content\Converter;
 6 | 
 7 | use Magento\Framework\Exception\LocalizedException;
 8 | 
 9 | interface CmsEntityConverterInterface
10 | {
11 |     const CMS_MEDIA_NODE = 'media';
12 |     const PAGE_ENTITY_CODE = 'pages';
13 |     const BLOCK_ENTITY_CODE = 'blocks';
14 | 
15 |     /**
16 |      * @param array $cmsEntities
17 |      *
18 |      * @return array
19 |      * @throws LocalizedException
20 |      */
21 |     public function convertToArray(array $cmsEntities): array;
22 | }
23 | 


--------------------------------------------------------------------------------
/Model/Content/Converter/CmsEntityConverterManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Content\Converter;
 6 | 
 7 | use Magento\Framework\Exception\LocalizedException;
 8 | use Overdose\CMSContent\Api\CmsEntityConverterManagerInterface;
 9 | 
10 | class CmsEntityConverterManager implements CmsEntityConverterManagerInterface
11 | {
12 |     /**
13 |      * @var CmsEntityConverterInterface[]
14 |      */
15 |     private $converters = [];
16 | 
17 |     /**
18 |      * @param array $converters
19 |      */
20 |     public function __construct(
21 |         array $converters
22 |     ) {
23 |         $this->converters = $converters;
24 |     }
25 | 
26 |     /**
27 |      * @inheritdoc
28 |      */
29 |     public function getConverter(string $type): CmsEntityConverterInterface
30 |     {
31 |         if (isset($this->converters[$type])) {
32 |             return $this->converters[$type];
33 |         }
34 |         throw new LocalizedException(__("Can't find converter"));
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Model/Content/Converter/Page/Converter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Content\Converter\Page;
 6 | 
 7 | use Magento\Cms\Api\Data\PageInterface;
 8 | use Magento\Framework\Exception\LocalizedException;
 9 | use Magento\Framework\Exception\NoSuchEntityException;
10 | use Overdose\CMSContent\Model\Content\Converter\AbstractConverter;
11 | use Overdose\CMSContent\Model\Content\Converter\CmsEntityConverterInterface;
12 | 
13 | class Converter extends AbstractConverter implements CmsEntityConverterInterface
14 | {
15 |     /**
16 |      * @inheritdoc
17 |      */
18 |     public function convertToArray(array $cmsEntities): array
19 |     {
20 |         $pages = [];
21 |         $media = [];
22 | 
23 |         foreach ($cmsEntities as $pageInterface) {
24 |             $pageInfo = $this->convertPageToArray($pageInterface);
25 |             $pages[$this->getPageKey($pageInterface)] = $pageInfo;
26 |             $media = array_merge($media, $pageInfo['media']);
27 |         }
28 | 
29 |         return [
30 |             self::PAGE_ENTITY_CODE => $pages,
31 |             'media' => $media,
32 |         ];
33 |     }
34 | 
35 |     /**
36 |      * Return CMS page to array
37 |      *
38 |      * @param PageInterface $pageInterface
39 |      *
40 |      * @return array
41 |      * @throws LocalizedException
42 |      */
43 |     public function convertPageToArray(PageInterface $pageInterface): array
44 |     {
45 |         // Extract attachments
46 |         $media = $this->getMediaAttachments($pageInterface->getContent());
47 | 
48 |          return [
49 |             'cms' => [
50 |                 PageInterface::IDENTIFIER => $pageInterface->getIdentifier(),
51 |                 PageInterface::TITLE => $pageInterface->getTitle(),
52 |                 PageInterface::PAGE_LAYOUT => $pageInterface->getPageLayout(),
53 |                 PageInterface::META_KEYWORDS => $pageInterface->getMetaKeywords(),
54 |                 PageInterface::META_DESCRIPTION => $pageInterface->getMetaDescription(),
55 |                 PageInterface::CONTENT_HEADING => $pageInterface->getContentHeading(),
56 |                 PageInterface::CONTENT => $pageInterface->getContent(),
57 |                 PageInterface::SORT_ORDER => $pageInterface->getSortOrder(),
58 |                 PageInterface::LAYOUT_UPDATE_XML => $pageInterface->getLayoutUpdateXml(),
59 |                 PageInterface::CUSTOM_THEME => $pageInterface->getCustomTheme(),
60 |                 PageInterface::CUSTOM_ROOT_TEMPLATE => $pageInterface->getCustomRootTemplate(),
61 |                 PageInterface::CUSTOM_LAYOUT_UPDATE_XML => $pageInterface->getCustomLayoutUpdateXml(),
62 |                 PageInterface::CUSTOM_THEME_FROM => $pageInterface->getCustomThemeFrom(),
63 |                 PageInterface::CUSTOM_THEME_TO => $pageInterface->getCustomThemeTo(),
64 |                 PageInterface::IS_ACTIVE => (string)$pageInterface->isActive(),
65 |             ],
66 |             'stores' => $this->getStoreCodes($pageInterface->getStores()),
67 |             'media' => $media,
68 |             'block_references' => $this->saveBlockByIdent($pageInterface->getContent()),
69 |         ];
70 |     }
71 | 
72 |     /**
73 |      * Get page unique key
74 |      *
75 |      * @param PageInterface $pageInterface
76 |      *
77 |      * @return string
78 |      * @throws NoSuchEntityException
79 |      */
80 |     private function getPageKey(PageInterface $pageInterface): string
81 |     {
82 |         $keys = $this->getStoreCodes($pageInterface->getStores());
83 |         $keys[] = $pageInterface->getIdentifier();
84 | 
85 |         return implode(':', $keys);
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/Model/Content/Export.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Model\Content;
  6 | 
  7 | use Magento\Framework\Exception\LocalizedException;
  8 | use Magento\Framework\Filesystem\Io\File;
  9 | use Overdose\CMSContent\Api\CmsEntityGeneratorManagerInterface;
 10 | use Overdose\CMSContent\Api\ContentExportInterface;
 11 | use Overdose\CMSContent\File\FileManagerInterface;
 12 | use Overdose\CMSContent\Model\Config;
 13 | use ZipArchive;
 14 | 
 15 | class Export implements ContentExportInterface
 16 | {
 17 |     const FILENAME = 'cms';
 18 |     const MEDIA_ARCHIVE_PATH = 'media';
 19 | 
 20 |     /**
 21 |      * @var CmsEntityGeneratorManagerInterface
 22 |      */
 23 |     private $cmsEntityGeneratorManager;
 24 | 
 25 |     /**
 26 |      * @var File
 27 |      */
 28 |     private $file;
 29 | 
 30 |     /**
 31 |      * @var FileManagerInterface
 32 |      */
 33 |     private $fileManager;
 34 | 
 35 |     /**
 36 |      * @var Config
 37 |      */
 38 |     private $config;
 39 | 
 40 |     /**
 41 |      * @param CmsEntityGeneratorManagerInterface $cmsEntityGeneratorManager
 42 |      * @param Config $config
 43 |      * @param FileManagerInterface $fileManager
 44 |      * @param File $file
 45 |      */
 46 |     public function __construct(
 47 |         CmsEntityGeneratorManagerInterface $cmsEntityGeneratorManager,
 48 |         Config $config,
 49 |         FileManagerInterface $fileManager,
 50 |         File $file
 51 |     ) {
 52 |         $this->cmsEntityGeneratorManager = $cmsEntityGeneratorManager;
 53 |         $this->config = $config;
 54 |         $this->file = $file;
 55 |         $this->fileManager = $fileManager;
 56 |     }
 57 | 
 58 |     /**
 59 |      * @inheridoc
 60 |      */
 61 |     public function createZipFile(
 62 |         array $convertedEntities,
 63 |         string $entityType,
 64 |         string $type,
 65 |         string $fileName,
 66 |         bool $split
 67 |     ): string {
 68 |         $exportPath = $this->fileManager->getFolder($this->config->getExportPath());
 69 | 
 70 |         $relativeZipFile = Config::CMS_DIR . DIRECTORY_SEPARATOR
 71 |             . Config::EXPORT_PATH . DIRECTORY_SEPARATOR
 72 |             . $fileName;
 73 | 
 74 |         $zipArchive = $this->putContentToZip(
 75 |             $convertedEntities,
 76 |             $entityType,
 77 |             $exportPath . '/' . $fileName,
 78 |             $type,
 79 |             $split
 80 |         );
 81 | 
 82 |         // Add media files
 83 |         foreach ($convertedEntities['media'] as $mediaFile) {
 84 |             //Strip Quotes if any
 85 |             $mediaFile = str_replace(['"',"&quot;","'"], '', $mediaFile);
 86 |             $absMediaPath = $this->fileManager->getMediaPath($mediaFile);
 87 |             if ($this->file->fileExists($absMediaPath, true)) {
 88 |                 $zipArchive->addFile($absMediaPath, self::MEDIA_ARCHIVE_PATH . '/' . $mediaFile);
 89 |             }
 90 |         }
 91 | 
 92 |         $zipArchive->close();
 93 | 
 94 |         // Clear export path
 95 |         $this->file->rm($relativeZipFile);
 96 | 
 97 |         return $relativeZipFile;
 98 |     }
 99 | 
100 |     /**
101 |      * @param array $contentArray
102 |      * @param string $cmsEntityCode
103 |      * @param string $zipFileName
104 |      * @param string $type
105 |      * @param bool $split
106 |      * @return ZipArchive
107 |      * @throws LocalizedException
108 |      */
109 |     private function putContentToZip(
110 |         array $contentArray,
111 |         string $cmsEntityCode,
112 |         string $zipFileName,
113 |         string $type,
114 |         bool $split
115 |     ): ZipArchive {
116 |         $zipArchive = new ZipArchive();
117 |         $zipArchive->open($zipFileName, ZipArchive::CREATE);
118 |         $generator = $this->cmsEntityGeneratorManager->getGenerator($type);
119 | 
120 |         if ($split) {
121 |             foreach ($contentArray[$cmsEntityCode] as $key => $content) {
122 |                 $payload = $generator->generate(
123 |                     [
124 |                         $cmsEntityCode => [$key => $content]
125 |                     ]
126 |                 );
127 | 
128 |                 $zipArchive->addFromString(
129 |                     sprintf(
130 |                         '%s_%s_%s.%s',
131 |                         self::FILENAME,
132 |                         $this->prepareEntityPartName($cmsEntityCode),
133 |                         $key,
134 |                         $type
135 |                     ),
136 |                     $payload
137 |                 );
138 |             }
139 |         } else {
140 |             $fullContent = [];
141 |             foreach ($contentArray[$cmsEntityCode] as $key => $content) {
142 |                 $entityContent = [
143 |                     $cmsEntityCode => [$key => $content]
144 |                 ];
145 |                 $fullContent = array_merge_recursive($fullContent, $entityContent);
146 |             }
147 |             $payload = $generator->generate($fullContent);
148 |             $zipArchive->addFromString(
149 |                 sprintf('%s_%s.%s', self::FILENAME, $this->prepareEntityPartName($cmsEntityCode), $type),
150 |                 $payload
151 |             );
152 |         }
153 | 
154 |         return $zipArchive;
155 |     }
156 | 
157 |     /**
158 |      * Prepare entity part name
159 |      *
160 |      * @param string $cmsEntityCode
161 |      *
162 |      * @return string
163 |      */
164 |     private function prepareEntityPartName(string $cmsEntityCode): string
165 |     {
166 |         return substr($cmsEntityCode, 0, strlen($cmsEntityCode) - 1) . '_data';
167 |     }
168 | }
169 | 


--------------------------------------------------------------------------------
/Model/Content/Generator/CmsEntityGeneratorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Content\Generator;
 6 | 
 7 | use Overdose\CMSContent\Model\Content\Converter\CmsEntityConverterInterface;
 8 | 
 9 | interface CmsEntityGeneratorInterface
10 | {
11 |     const PAGE_SCHEMA_NAME = 'cms_page_data.xsd';
12 |     const BLOCK_SCHEMA_NAME = 'cms_block_data.xsd';
13 | 
14 |     const XSD_TYPE_MAP = [
15 |         CmsEntityConverterInterface::PAGE_ENTITY_CODE => self::PAGE_SCHEMA_NAME,
16 |         CmsEntityConverterInterface::BLOCK_ENTITY_CODE => self::BLOCK_SCHEMA_NAME
17 |     ];
18 | 
19 |     const MAIN_ENTITY_NODE_NAME = 'cms';
20 |     const STORES_ENTITY_NODE_NAME = 'stores';
21 | 
22 |     /**
23 |      * Call generate action
24 |      *
25 |      * @param array $data
26 |      *
27 |      * @return string
28 |      */
29 |     public function generate(array $data): string;
30 | }
31 | 


--------------------------------------------------------------------------------
/Model/Content/Generator/CmsEntityGeneratorManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Content\Generator;
 6 | 
 7 | use Magento\Framework\Exception\LocalizedException;
 8 | use Overdose\CMSContent\Api\CmsEntityGeneratorManagerInterface;
 9 | 
10 | class CmsEntityGeneratorManager implements CmsEntityGeneratorManagerInterface
11 | {
12 |     /**
13 |      * @var CmsEntityGeneratorInterface[]
14 |      */
15 |     private $generators = [];
16 | 
17 |     /**
18 |      * @param array $generators
19 |      */
20 |     public function __construct(
21 |         array $generators
22 |     ) {
23 |         $this->generators = $generators;
24 |     }
25 | 
26 |     /**
27 |      * @inheritdoc
28 |      */
29 |     public function getGenerator($type): CmsEntityGeneratorInterface
30 |     {
31 |         if (isset($this->generators[$type])) {
32 |             return $this->generators[$type];
33 |         }
34 |         throw new LocalizedException(__("Can't find generator"));
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Model/Content/Generator/Json/Generator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Content\Generator\Json;
 6 | 
 7 | use Magento\Framework\Serialize\SerializerInterface;
 8 | use Overdose\CMSContent\Model\Content\Generator\CmsEntityGeneratorInterface;
 9 | 
10 | class Generator implements CmsEntityGeneratorInterface
11 | {
12 |     /**
13 |      * @var SerializerInterface
14 |      */
15 |     private $serializerInterface;
16 | 
17 |     /**
18 |      * @param SerializerInterface $serializerInterface
19 |      */
20 |     public function __construct(
21 |         SerializerInterface $serializerInterface
22 |     ) {
23 |         $this->serializerInterface = $serializerInterface;
24 |     }
25 | 
26 |     /**
27 |      * @param array $data
28 |      *
29 |      * @return string
30 |      */
31 |     public function generate(array $data): string
32 |     {
33 |         return $this->serializerInterface->serialize($data);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/Model/ContentVersion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model;
 6 | 
 7 | use Magento\Framework\Model\AbstractModel;
 8 | use Overdose\CMSContent\Api\Data\ContentVersionInterface;
 9 | use Overdose\CMSContent\Model\ResourceModel\ContentVersion as ResourceContentVersion;
10 | 
11 | class ContentVersion extends AbstractModel implements ContentVersionInterface
12 | {
13 |     /**
14 |      * @inheritdoc
15 |      */
16 |     protected function _construct()
17 |     {
18 |         $this->_init(ResourceContentVersion::class);
19 |     }
20 | 
21 |     /**
22 |      * @inheritdoc
23 |      */
24 |     public function getType(): ?string
25 |     {
26 |         return $this->getData(self::TYPE);
27 |     }
28 | 
29 |     /**
30 |      * @inheritdoc
31 |      */
32 |     public function setType(string $type): ContentVersionInterface
33 |     {
34 |         return $this->setData(self::TYPE, $type);
35 |     }
36 | 
37 |     /**
38 |      * @inheritdoc
39 |      */
40 |     public function getIdentifier(): ?string
41 |     {
42 |         return $this->getData(self::IDENTIFIER);
43 |     }
44 | 
45 |     /**
46 |      * @inheritdoc
47 |      */
48 |     public function setIdentifier(string $identifier): ContentVersionInterface
49 |     {
50 |         return $this->setData(self::IDENTIFIER, $identifier);
51 |     }
52 | 
53 |     /**
54 |      * @inheritdoc
55 |      */
56 |     public function getVersion(): ?string
57 |     {
58 |         return $this->getData(self::VERSION);
59 |     }
60 | 
61 |     /**
62 |      * @inheritdoc
63 |      */
64 |     public function setVersion(string $version): ContentVersionInterface
65 |     {
66 |         return $this->setData(self::VERSION, $version);
67 |     }
68 | 
69 |     /**
70 |      * @inheritdoc
71 |      */
72 |     public function getStoreIds(): ?string
73 |     {
74 |         return $this->getData(self::STORE_IDS);
75 |     }
76 | 
77 |     /**
78 |      * @inheritdoc
79 |      */
80 |     public function setStoreIds(string $storeIds): ContentVersionInterface
81 |     {
82 |         return $this->setData(self::STORE_IDS, $storeIds);
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/Model/ContentVersionRepository.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Model;
  6 | 
  7 | use Magento\Framework\Api\SearchCriteriaInterface;
  8 | use Magento\Framework\Api\SearchResultsInterface;
  9 | use Magento\Framework\Api\SearchResultsInterfaceFactory;
 10 | use Overdose\CMSContent\Api\Data\ContentVersionInterface;
 11 | use Magento\Framework\Exception\CouldNotSaveException;
 12 | use Overdose\CMSContent\Model\ResourceModel\ContentVersion\CollectionFactory as ContentVersionCollectionFactory;
 13 | use Magento\Framework\Api\SearchCriteria\CollectionProcessorInterface;
 14 | use Magento\Framework\Exception\CouldNotDeleteException;
 15 | use Overdose\CMSContent\Api\ContentVersionRepositoryInterface;
 16 | use Overdose\CMSContent\Model\ResourceModel\ContentVersion as ResourceContentVersion;
 17 | use Magento\Framework\Exception\NoSuchEntityException;
 18 | 
 19 | class ContentVersionRepository implements ContentVersionRepositoryInterface
 20 | {
 21 |     /**
 22 |      * @var SearchResultsInterfaceFactory
 23 |      */
 24 |     private $searchResultsFactory;
 25 | 
 26 |     /**
 27 |      * @var ResourceContentVersion
 28 |      */
 29 |     private $resource;
 30 | 
 31 |     /**
 32 |      * @var ContentVersionCollectionFactory
 33 |      */
 34 |     private $contentVersionCollectionFactory;
 35 | 
 36 |     /**
 37 |      * @var ContentVersionFactory
 38 |      */
 39 |     private $contentVersionFactory;
 40 | 
 41 |     /**
 42 |      * @var CollectionProcessorInterface
 43 |      */
 44 |     private $collectionProcessor;
 45 | 
 46 |     /**
 47 |      * ContentVersionRepository constructor
 48 |      *
 49 |      * @param ResourceContentVersion $resource
 50 |      * @param ContentVersionFactory $contentVersionFactory
 51 |      * @param ContentVersionCollectionFactory $contentVersionCollectionFactory
 52 |      * @param SearchResultsInterfaceFactory $searchResultsFactory
 53 |      * @param CollectionProcessorInterface $collectionProcessor
 54 |      */
 55 |     public function __construct(
 56 |         ResourceContentVersion $resource,
 57 |         ContentVersionFactory $contentVersionFactory,
 58 |         ContentVersionCollectionFactory $contentVersionCollectionFactory,
 59 |         SearchResultsInterfaceFactory $searchResultsFactory,
 60 |         CollectionProcessorInterface $collectionProcessor
 61 |     ) {
 62 |         $this->resource = $resource;
 63 |         $this->contentVersionFactory = $contentVersionFactory;
 64 |         $this->contentVersionCollectionFactory = $contentVersionCollectionFactory;
 65 |         $this->searchResultsFactory = $searchResultsFactory;
 66 |         $this->collectionProcessor = $collectionProcessor;
 67 |     }
 68 | 
 69 |     /**
 70 |      * @inheritdoc
 71 |      */
 72 |     public function save(ContentVersionInterface $contentVersion): ContentVersionInterface
 73 |     {
 74 |         try {
 75 |             $this->resource->save($contentVersion);
 76 | 
 77 |             return $this->get($contentVersion->getId());
 78 |         } catch (\Exception $exception) {
 79 |             throw new CouldNotSaveException(
 80 |                 __('Could not save the contentVersion: %1', $exception->getMessage())
 81 |             );
 82 |         }
 83 |     }
 84 | 
 85 |     /**
 86 |      * @inheritdoc
 87 |      */
 88 |     public function get(string $id): ContentVersionInterface
 89 |     {
 90 |         $contentVersion = $this->contentVersionFactory->create();
 91 |         $this->resource->load($contentVersion, $id);
 92 |         if (!$contentVersion->getId()) {
 93 |             throw new NoSuchEntityException(__('content_version with id "%1" does not exist.', $id));
 94 |         }
 95 |         return $contentVersion;
 96 |     }
 97 | 
 98 |     /**
 99 |      * @inheritdoc
100 |      */
101 |     public function getList(SearchCriteriaInterface $searchCriteria): SearchResultsInterface
102 |     {
103 |         $collection = $this->contentVersionCollectionFactory->create();
104 | 
105 |         $this->collectionProcessor->process($searchCriteria, $collection);
106 | 
107 |         $searchResult = $this->searchResultsFactory->create();
108 |         $searchResult->setItems($collection->getItems());
109 |         $searchResult->setTotalCount($collection->getSize());
110 |         $searchResult->setSearchCriteria($searchCriteria);
111 | 
112 |         return $searchResult;
113 |     }
114 | 
115 |     /**
116 |      * @inheritdoc
117 |      */
118 |     public function delete(ContentVersionInterface $contentVersion): bool
119 |     {
120 |         try {
121 |             $contentVersionModel = $this->contentVersionFactory->create();
122 |             $this->resource->load($contentVersionModel, $contentVersion->getId());
123 |             $this->resource->delete($contentVersionModel);
124 |         } catch (\Exception $exception) {
125 |             throw new CouldNotDeleteException(__(
126 |                 'Could not delete the content_version: %1',
127 |                 $exception->getMessage()
128 |             ));
129 |         }
130 |         return true;
131 |     }
132 | 
133 |     /**
134 |      * @inheritdoc
135 |      */
136 |     public function deleteById($id): bool
137 |     {
138 |         return $this->delete($this->get($id));
139 |     }
140 | }
141 | 


--------------------------------------------------------------------------------
/Model/Dir/Reader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\Dir;
 6 | 
 7 | use Magento\Framework\Module\Dir;
 8 | use Overdose\CMSContent\Model\Config\Block\Reader as BlockReader;
 9 | use Overdose\CMSContent\Model\Config\Page\Reader as PageReader;
10 | use Overdose\CMSContent\Model\Config\ReaderAbstract;
11 | 
12 | class Reader extends \Magento\Framework\Module\Dir\Reader
13 | {
14 |     /**
15 |      * Found configuration files grouped by configuration types (filename).
16 |      *
17 |      * @var array
18 |      */
19 |     private $fileIterators = [];
20 |     
21 |     /**
22 |      * @inheridoc
23 |      */
24 |     public function getConfigurationFiles($filename)
25 |     {
26 |         return $this->getFilesIterator($filename, Dir::MODULE_ETC_DIR);
27 |     }
28 | 
29 |     /**
30 |      * @inheridoc
31 |      */
32 |     private function getFilesIterator($filename, $subDir = '')
33 |     {
34 |         if (!isset($this->fileIterators[$subDir][$filename])) {
35 |             $this->fileIterators[$subDir][$filename] = $this->fileIteratorFactory->create(
36 |                 $this->getFiles($filename, $subDir)
37 |             );
38 |         }
39 |         return $this->fileIterators[$subDir][$filename];
40 |     }
41 | 
42 |     /**
43 |      * @inheridoc
44 |      */
45 |     private function getFiles($filename, $subDir = '')
46 |     {
47 |         $result = [];
48 |         foreach ($this->modulesList->getNames() as $moduleName) {
49 |             try {
50 |                 $moduleSubDir = $this->getModuleDir($subDir, $moduleName);
51 |             } catch (\InvalidArgumentException $e) {
52 |                 continue;
53 |             }
54 |             $file = $moduleSubDir . '/' . $filename;
55 |             $directoryRead = $this->readFactory->create($moduleSubDir);
56 |             $path = $directoryRead->getRelativePath($file);
57 |             if ($directoryRead->isExist($path)) {
58 |                 $result[] = $file;
59 |             }
60 |             // === Overdose - the override part BEGIN ===
61 |             if ($filename === BlockReader::FILE_NAME || $filename === PageReader::FILE_NAME) {
62 |                 $pattern = substr($filename, 0, strlen($filename) - 4);
63 |                 $dir = $moduleSubDir . '/' . ReaderAbstract::OD_CONFIG_DIR_NAME;
64 |                 $directoryRead = $this->readFactory->create($dir);
65 |                 $path = $directoryRead->getRelativePath($dir);
66 |                 if ($directoryRead->isExist($path)) {
67 |                     $odFiles = array_filter($directoryRead->read($path), function ($file) use ($pattern) {
68 |                         return strpos($file, $pattern) === 0 && substr($file, -4) === '.xml';
69 |                     });
70 |                     array_walk($odFiles, function (&$file) use ($dir) {
71 |                         $file = $dir . '/' . $file;
72 |                     });
73 |                     $result = array_merge($odFiles, $result);
74 |                 }
75 |             }
76 |             // === Overdose - the override part END ===
77 |         }
78 |         return $result;
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/Model/EntityManagement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model;
 6 | 
 7 | use Magento\Cms\Api\BlockRepositoryInterface;
 8 | use Magento\Cms\Api\Data\BlockInterface;
 9 | use Magento\Cms\Api\Data\PageInterface;
10 | use Magento\Cms\Api\PageRepositoryInterface;
11 | use Magento\Framework\Exception\LocalizedException;
12 | 
13 | class EntityManagement
14 | {
15 |     /**#@+
16 |      * Types
17 |      */
18 |     const TYPE_BLOCK = 'block';
19 |     const TYPE_PAGE = 'page';
20 |     /**#@-*/
21 | 
22 |     /**
23 |      * @var array
24 |      */
25 |     private $repositoryList = [];
26 | 
27 |     /**
28 |      * @var array
29 |      */
30 |     private $factoryList = [];
31 | 
32 |     /**
33 |      * @param array $repositoryList
34 |      * @param array $factoryList
35 |      */
36 |     public function __construct(
37 |         array $repositoryList = [],
38 |         array $factoryList = []
39 |     ) {
40 |         $this->repositoryList = $repositoryList;
41 |         $this->factoryList = $factoryList;
42 |     }
43 | 
44 |     /**
45 |      * Get repository
46 |      *
47 |      * @return BlockRepositoryInterface|PageRepositoryInterface
48 |      * @throws LocalizedException
49 |      */
50 |     public function getRepository(string $type)
51 |     {
52 |         if (isset($this->repositoryList[$type])) {
53 |             return $this->repositoryList[$type];
54 |         }
55 |         throw new LocalizedException(__('Expected entity instance not found.'));
56 |     }
57 | 
58 |     /**
59 |      * Get repository
60 |      *
61 |      * @return BlockInterface|PageInterface
62 |      * @throws LocalizedException
63 |      */
64 |     public function getFactory(string $type)
65 |     {
66 |         if (isset($this->factoryList[$type])) {
67 |             return $this->factoryList[$type]->create();
68 |         }
69 |         throw new LocalizedException(__('Expected entity instance not found.'));
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/Model/OptionSource/CmsMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\OptionSource;
 6 | 
 7 | use Magento\Framework\Data\OptionSourceInterface;
 8 | use Overdose\CMSContent\Api\ContentImportInterface;
 9 | 
10 | class CmsMode implements OptionSourceInterface
11 | {
12 |     /**
13 |      * To option array
14 |      *
15 |      * @return array
16 |      */
17 |     public function toOptionArray(): array
18 |     {
19 |         return [
20 |             [
21 |                 'label' => __('Overwrite existing'),
22 |                 'value' => ContentImportInterface::OD_CMS_MODE_UPDATE
23 |             ],
24 |             [
25 |                 'label' => __('Skip existing'),
26 |                 'value' => ContentImportInterface::OD_CMS_MODE_SKIP
27 |             ]
28 |         ];
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Model/OptionSource/MediaMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\OptionSource;
 6 | 
 7 | use Magento\Framework\Data\OptionSourceInterface;
 8 | use Overdose\CMSContent\Api\ContentImportInterface;
 9 | 
10 | class MediaMode implements OptionSourceInterface
11 | {
12 |     /**
13 |      * To option array
14 |      *
15 |      * @return array
16 |      */
17 |     public function toOptionArray(): array
18 |     {
19 |         return [
20 |             [
21 |                 'label' => __('Do not import'),
22 |                 'value' => ContentImportInterface::OD_MEDIA_MODE_NONE
23 |             ],
24 |             [
25 |                 'label' => __('Overwrite existing'),
26 |                 'value' => ContentImportInterface::OD_MEDIA_MODE_UPDATE
27 |             ],
28 |             [
29 |                 'label' => __('Skip existing'),
30 |                 'value' => ContentImportInterface::OD_MEDIA_MODE_SKIP
31 |             ]
32 |         ];
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Model/OptionSource/Methods.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\OptionSource;
 6 | 
 7 | use Magento\Framework\Data\OptionSourceInterface;
 8 | use Overdose\CMSContent\Model\Config;
 9 | 
10 | class Methods implements OptionSourceInterface
11 | {
12 |     /**
13 |      * @return array
14 |      */
15 |     public function toOptionArray(): array
16 |     {
17 |         return [
18 |             [
19 |                 'label' => __('By Periods'),
20 |                 'value' => Config::PERIOD
21 |             ],
22 |             [
23 |                 'label' => __('Older Than'),
24 |                 'value' => Config::OLDER_THAN
25 |             ]
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/Model/OptionSource/Periods.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\OptionSource;
 6 | 
 7 | use Magento\Framework\Data\OptionSourceInterface;
 8 | use Overdose\CMSContent\Model\Config;
 9 | 
10 | class Periods implements OptionSourceInterface
11 | {
12 |     /**
13 |      * @return array
14 |      */
15 |     public function toOptionArray(): array
16 |     {
17 |         return [
18 |             [
19 |                 'label' => __('Days'),
20 |                 'value' => Config::DAY
21 |             ],
22 |             [
23 |                 'label' => __('Weeks'),
24 |                 'value' => Config::WEEK
25 |             ],
26 |             [
27 |                 'label' => __('Months'),
28 |                 'value' => Config::MONTH
29 |             ],
30 |             [
31 |                 'label' => __('Years'),
32 |                 'value' => Config::YEAR
33 |             ]
34 |         ];
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Model/ResourceModel/ContentVersion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\ResourceModel;
 6 | 
 7 | use Magento\Framework\Model\AbstractModel;
 8 | use Magento\Framework\Model\ResourceModel\Db\AbstractDb;
 9 | use Overdose\CMSContent\Api\Data\ContentVersionInterface;
10 | 
11 | class ContentVersion extends AbstractDb
12 | {
13 |     /**
14 |      * Define resource model
15 |      *
16 |      * @return void
17 |      */
18 |     protected function _construct()
19 |     {
20 |         $this->_init('od_cmscontent_version', 'id');
21 |     }
22 | 
23 |     /**
24 |      * @inheritDoc
25 |      */
26 |     protected function _beforeSave(AbstractModel $object)
27 |     {
28 |         if (empty($storeIds = $object->getData(ContentVersionInterface::STORE_IDS))) {
29 |             $storeIds = '0';
30 |         } else {
31 |             $storeIdsArray = explode(',', $storeIds);
32 |             if (in_array('0', $storeIdsArray)) {
33 |                 $storeIds = '0';
34 |             }
35 |         }
36 | 
37 |         $object->setData(ContentVersionInterface::STORE_IDS, $storeIds);
38 | 
39 |         return parent::_beforeSave($object);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/Model/ResourceModel/ContentVersion/Collection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model\ResourceModel\ContentVersion;
 6 | 
 7 | use Magento\Framework\Model\ResourceModel\Db\Collection\AbstractCollection;
 8 | use Overdose\CMSContent\Model\ContentVersion;
 9 | use Overdose\CMSContent\Model\ResourceModel\ContentVersion as ResourceContentVersion;
10 | 
11 | class Collection extends AbstractCollection
12 | {
13 |     /**
14 |      * Define resource model
15 |      *
16 |      * @return void
17 |      */
18 |     protected function _construct()
19 |     {
20 |         $this->_init(ContentVersion::class, ResourceContentVersion::class);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/Model/Service/GetCmsEntityItems.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Model\Service;
  6 | 
  7 | use Magento\Cms\Api\BlockRepositoryInterface;
  8 | use Magento\Cms\Api\PageRepositoryInterface;
  9 | use Magento\Framework\Api\FilterBuilder;
 10 | use Magento\Framework\Api\Search\FilterGroupBuilder;
 11 | use Magento\Framework\Api\SearchCriteria;
 12 | use Magento\Framework\Api\SearchCriteriaBuilder;
 13 | use Magento\Framework\Exception\LocalizedException;
 14 | use Overdose\CMSContent\Model\EntityManagement;
 15 | 
 16 | /**
 17 |  * Class GetCmsEntityItems
 18 |  */
 19 | class GetCmsEntityItems
 20 | {
 21 |     /**
 22 |      * @var SearchCriteriaBuilder
 23 |      */
 24 |     private $searchCriteriaBuilder;
 25 | 
 26 |     /**
 27 |      * @var FilterBuilder
 28 |      */
 29 |     private $filterBuilder;
 30 | 
 31 |     /**
 32 |      * @var FilterGroupBuilder
 33 |      */
 34 |     private $filterGroupBuilder;
 35 | 
 36 |     /**
 37 |      * @var EntityManagement
 38 |      */
 39 |     private $entityManagement;
 40 | 
 41 |     /**
 42 |      * @param SearchCriteriaBuilder $searchCriteriaBuilder
 43 |      * @param FilterBuilder $filterBuilder
 44 |      * @param FilterGroupBuilder $filterGroupBuilder
 45 |      * @param EntityManagement $entityManagement
 46 |      */
 47 |     public function __construct(
 48 |         SearchCriteriaBuilder $searchCriteriaBuilder,
 49 |         FilterBuilder $filterBuilder,
 50 |         FilterGroupBuilder $filterGroupBuilder,
 51 |         EntityManagement $entityManagement
 52 |     ) {
 53 |         $this->searchCriteriaBuilder = $searchCriteriaBuilder;
 54 |         $this->filterBuilder = $filterBuilder;
 55 |         $this->filterGroupBuilder = $filterGroupBuilder;
 56 |         $this->entityManagement = $entityManagement;
 57 |     }
 58 | 
 59 |     /**
 60 |      * Get Cms items
 61 |      *
 62 |      * /**
 63 |      * @param string $type
 64 |      * @param string $identifier
 65 |      * @param array $storeIds
 66 |      *
 67 |      * @return array
 68 |      * @throws LocalizedException
 69 |      */
 70 |     public function execute(string $type, string $identifier, array $storeIds): array
 71 |     {
 72 |         $repository = $this->getCmsRepository($type);
 73 | 
 74 |         $searchCriteria = $this->prepareSearchCriteria($identifier, $storeIds);
 75 | 
 76 |         return $repository->getList($searchCriteria)->getItems();
 77 |     }
 78 | 
 79 |     /**
 80 |      * Retrieve repository for cms-block or cms-page
 81 |      *
 82 |      * @param string $type
 83 |      *
 84 |      * @return BlockRepositoryInterface|PageRepositoryInterface
 85 |      * @throws LocalizedException
 86 |      */
 87 |     private function getCmsRepository(string $type)
 88 |     {
 89 |         return $this->entityManagement->getRepository($type);
 90 |     }
 91 | 
 92 |     /**
 93 |      * Prepare search criteria
 94 |      *
 95 |      * @param string $identifier
 96 |      * @param array $storeIds
 97 |      *
 98 |      * @return SearchCriteria
 99 |      */
100 |     private function prepareSearchCriteria(string $identifier, array $storeIds): SearchCriteria
101 |     {
102 |         $filtersGroups = [];
103 | 
104 |         $filterIdentifier = $this->filterBuilder
105 |             ->setField('identifier')
106 |             ->setConditionType('eq')
107 |             ->setValue($identifier)
108 |             ->create();
109 |         $filterGroup1 = $this->filterGroupBuilder
110 |             ->setFilters([$filterIdentifier])
111 |             ->create();
112 |         $filtersGroups[] = $filterGroup1;
113 | 
114 |         $filterStore = $this->filterBuilder
115 |             ->setField('store_id')
116 |             ->setConditionType('in')
117 |             ->setValue($storeIds)
118 |             ->create();
119 |         $filterGroup2 = $this->filterGroupBuilder
120 |             ->setFilters([$filterStore])
121 |             ->create();
122 |         $filtersGroups[] = $filterGroup2;
123 | 
124 |         return $this->searchCriteriaBuilder
125 |             ->setFilterGroups($filtersGroups)
126 |             ->create();
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/Model/Service/GetContentVersions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Model\Service;
  6 | 
  7 | use Magento\Framework\Api\FilterBuilder;
  8 | use Magento\Framework\Api\Search\FilterGroupBuilder;
  9 | use Magento\Framework\Api\SearchCriteria;
 10 | use Magento\Framework\Api\SearchCriteriaBuilder;
 11 | use Magento\Framework\Exception\LocalizedException;
 12 | use Overdose\CMSContent\Api\ContentVersionRepositoryInterface;
 13 | use Overdose\CMSContent\Api\Data\ContentVersionInterface;
 14 | use Overdose\CMSContent\Model\ContentVersion;
 15 | use Psr\Log\LoggerInterface;
 16 | 
 17 | /**
 18 |  * Class GetContentVersions
 19 |  */
 20 | class GetContentVersions
 21 | {
 22 |     /**
 23 |      * @var SearchCriteriaBuilder
 24 |      */
 25 |     private $searchCriteriaBuilder;
 26 | 
 27 |     /**
 28 |      * @var FilterBuilder
 29 |      */
 30 |     private $filterBuilder;
 31 | 
 32 |     /**
 33 |      * @var FilterGroupBuilder
 34 |      */
 35 |     private $filterGroupBuilder;
 36 | 
 37 |     /**
 38 |      * @var ContentVersionRepositoryInterface
 39 |      */
 40 |     private $contentVersionRepository;
 41 | 
 42 |     /**
 43 |      * @var LoggerInterface
 44 |      */
 45 |     private $logger;
 46 | 
 47 |     /**
 48 |      * @param SearchCriteriaBuilder $searchCriteriaBuilder
 49 |      * @param FilterBuilder $filterBuilder
 50 |      * @param FilterGroupBuilder $filterGroupBuilder
 51 |      * @param ContentVersionRepositoryInterface $contentVersionRepository
 52 |      * @param LoggerInterface $logger
 53 |      */
 54 |     public function __construct(
 55 |         SearchCriteriaBuilder $searchCriteriaBuilder,
 56 |         FilterBuilder $filterBuilder,
 57 |         FilterGroupBuilder $filterGroupBuilder,
 58 |         ContentVersionRepositoryInterface $contentVersionRepository,
 59 |         LoggerInterface $logger
 60 |     ) {
 61 |         $this->searchCriteriaBuilder = $searchCriteriaBuilder;
 62 |         $this->filterBuilder = $filterBuilder;
 63 |         $this->filterGroupBuilder = $filterGroupBuilder;
 64 |         $this->contentVersionRepository = $contentVersionRepository;
 65 |         $this->logger = $logger;
 66 |     }
 67 | 
 68 |     /**
 69 |      * Retrieves all CMS content records from DB based on type (0 - blocks, 1-pages), filtered by identifiers
 70 |      *
 71 |      * @param int $type
 72 |      * @param array $filterIds
 73 |      *
 74 |      * @return array
 75 |      */
 76 |     public function execute(int $type, array $filterIds): array
 77 |     {
 78 |         $result = [];
 79 | 
 80 |         try {
 81 |             $searchCriteria = $this->prepareSearchCriteria($type, $filterIds);
 82 | 
 83 |             $searchResult = $this->contentVersionRepository->getList($searchCriteria)->getItems();
 84 | 
 85 |             /** @var ContentVersion $item */
 86 |             foreach ($searchResult as $item) {
 87 |                 $storePart = str_replace(',', '_', $item->getStoreIds());
 88 |                 $key = $item->getIdentifier() . '_' . $storePart;
 89 |                 $result[$key] = $item;
 90 |             }
 91 |             return $result;
 92 |         } catch (LocalizedException $e) {
 93 |             $this->logger->critical(__('Something went wrong during getting content versions'));
 94 |         }
 95 |         return $result;
 96 |     }
 97 | 
 98 |     /**
 99 |      * Prepare search criteria
100 |      *
101 |      * @param int $type
102 |      * @param array $filterIds
103 |      *
104 |      * @return SearchCriteria
105 |      */
106 |     private function prepareSearchCriteria(int $type, array $filterIds): SearchCriteria
107 |     {
108 |         $filtersGroups = [];
109 | 
110 |         $filterType = $this->filterBuilder
111 |             ->setField(ContentVersionInterface::TYPE)
112 |             ->setConditionType('eq')
113 |             ->setValue($type)
114 |             ->create();
115 |         $filterGroup1 = $this->filterGroupBuilder
116 |             ->setFilters([$filterType])
117 |             ->create();
118 |         $filtersGroups[] = $filterGroup1;
119 | 
120 |         if (count($filterIds)) {
121 |             $filterId = $this->filterBuilder
122 |                 ->setField(ContentVersionInterface::IDENTIFIER)
123 |                 ->setConditionType('in')
124 |                 ->setValue(implode(",", $filterIds))
125 |                 ->create();
126 |             $filterGroup2 = $this->filterGroupBuilder
127 |                 ->setFilters([$filterId])
128 |                 ->create();
129 |             $filtersGroups[] = $filterGroup2;
130 |         }
131 | 
132 |         return $this->searchCriteriaBuilder
133 |             ->setFilterGroups($filtersGroups)
134 |             ->create();
135 |     }
136 | }
137 | 


--------------------------------------------------------------------------------
/Model/StoreManagement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Model;
 6 | 
 7 | use Magento\Framework\Exception\NoSuchEntityException;
 8 | use Magento\Store\Api\StoreRepositoryInterface;
 9 | use Overdose\CMSContent\Api\StoreManagementInterface;
10 | 
11 | class StoreManagement implements StoreManagementInterface
12 | {
13 |     /**
14 |      * @var StoreRepositoryInterface
15 |      */
16 |     private $storeRepositoryInterface;
17 | 
18 |     /**
19 |      * @param StoreRepositoryInterface $storeRepositoryInterface
20 |      */
21 |     public function __construct(StoreRepositoryInterface $storeRepositoryInterface)
22 |     {
23 |         $this->storeRepositoryInterface = $storeRepositoryInterface;
24 |     }
25 | 
26 |     /**
27 |      * Get store ids by codes
28 |      * @param array $storeCodes
29 |      * @return array
30 |      */
31 |     public function getStoreIdsByCodes(array $storeCodes): array
32 |     {
33 |         $storeCodes = $this->filterStoresByStoreCodes($storeCodes);
34 |         $storeIds = [];
35 |         foreach ($storeCodes as $storeCode) {
36 |             if ($storeCode == 'admin') {
37 |                 $storeIds[] = 0;
38 |             } else {
39 |                 try {
40 |                     $store = $this->storeRepositoryInterface->get($storeCode);
41 |                     if ($store && $store->getId()) {
42 |                         $storeIds[] = $store->getId();
43 |                     }
44 |                 } catch (NoSuchEntityException $exception) {
45 |                     continue;
46 |                 }
47 |             }
48 |         }
49 |         return $storeIds;
50 |     }
51 | 
52 |     /**
53 |      * Filter stores passed to import by existed
54 |      *
55 |      * @param array $storeCodes
56 |      *
57 |      * @return array
58 |      */
59 |     public function filterStoresByStoreCodes(array $storeCodes): array
60 |     {
61 |         $filteredStores = [];
62 |         $allStores = $this->storeRepositoryInterface->getList();
63 |         foreach ($storeCodes as $storeCode) {
64 |             if (array_key_exists($storeCode, $allStores)) {
65 |                 $filteredStores[] = $storeCode;
66 |             }
67 |         }
68 |         return $filteredStores;
69 |     }
70 | 
71 |     /**
72 |      * Filter stores passed to import by existed
73 |      *
74 |      * @param array $storeIds
75 |      *
76 |      * @return array
77 |      */
78 |     public function filterStoresByStoreIds(array $storeIds): array
79 |     {
80 |         $filteredStores = [];
81 |         $allStores = $this->storeRepositoryInterface->getList();
82 |         foreach ($allStores as $store) {
83 |             if (in_array($store->getId(), $storeIds)) {
84 |                 $filteredStores[] = $store->getId();
85 |             }
86 |         }
87 |         return $filteredStores;
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/Observer/CmsSaveBefore.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Observer;
 6 | 
 7 | use Magento\Framework\Event\Observer;
 8 | use Magento\Framework\Event\ObserverInterface;
 9 | use Overdose\CMSContent\Model\BackupManager;
10 | 
11 | class CmsSaveBefore implements ObserverInterface
12 | {
13 |     /**
14 |      * Events map to process
15 |      *
16 |      * @var array
17 |      */
18 |     private $eventsTypeMap = [
19 |         'cms_block_save_before' => BackupManager::TYPE_CMS_BLOCK,
20 |         'cms_page_save_before' => BackupManager::TYPE_CMS_PAGE,
21 |     ];
22 | 
23 |     /**
24 |      * Add keys to check if data was changed
25 |      *
26 |      * @var array
27 |      */
28 |     private $keysToCheck = [
29 |         'identifier',
30 |         'title',
31 |         'content',
32 |         'content_heading',
33 |     ];
34 | 
35 |     /**
36 |      * @var BackupManager
37 |      */
38 |     private $backupManager;
39 | 
40 |     /**
41 |      * CmsSaveBefore constructor.
42 |      *
43 |      * @param BackupManager $backupManager
44 |      */
45 |     public function __construct(
46 |         BackupManager $backupManager
47 |     ) {
48 |         $this->backupManager = $backupManager;
49 |     }
50 | 
51 |     /**
52 |      * @inheritDoc
53 |      */
54 |     public function execute(Observer $observer)
55 |     {
56 |         $eventName = $observer->getEvent()->getName();
57 |         if (empty($this->eventsTypeMap[$eventName])) {
58 |             return;
59 |         }
60 | 
61 |         $cmsObject = $observer->getEvent()->getData('data_object');
62 |         if ($this->hasImportantDataChanges($cmsObject)) {
63 |             $this->backupManager->createBackup($this->eventsTypeMap[$eventName], $cmsObject);
64 |         }
65 |     }
66 | 
67 |     /**
68 |      * Check if cms object was changed
69 |      *
70 |      * @param $cmsObject
71 |      *
72 |      * @return bool
73 |      */
74 |     private function hasImportantDataChanges($cmsObject): bool
75 |     {
76 |         foreach ($this->keysToCheck as $key) {
77 |             if ($cmsObject->getOrigData() && $cmsObject->getData($key) !== $cmsObject->getOrigData($key)) {
78 |                 return true;
79 |             }
80 |         }
81 |         return false;
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/Observer/DeleteContentVersion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Observer;
 6 | 
 7 | use Magento\Cms\Api\Data\BlockInterface;
 8 | use Magento\Cms\Api\Data\PageInterface;
 9 | use Magento\Framework\Event\Observer;
10 | use Magento\Framework\Event\ObserverInterface;
11 | use Overdose\CMSContent\Api\ContentVersionManagementInterface;
12 | use Overdose\CMSContent\Api\Data\ContentVersionInterface;
13 | 
14 | class DeleteContentVersion implements ObserverInterface
15 | {
16 |     /**
17 |      * Events map to process
18 |      *
19 |      * @var array
20 |      */
21 |     private $eventsTypeMap = [
22 |         'cms_page_delete_commit_after' => ContentVersionInterface::TYPE_PAGE,
23 |         'cms_block_delete_commit_after' => ContentVersionInterface::TYPE_BLOCK,
24 |     ];
25 | 
26 |     /**
27 |      * @var ContentVersionManagementInterface
28 |      */
29 |     private $contentVersionManagement;
30 | 
31 |     /**
32 |      * @param ContentVersionManagementInterface $contentVersionManagement
33 |      */
34 |     public function __construct(
35 |         ContentVersionManagementInterface $contentVersionManagement
36 |     ) {
37 |         $this->contentVersionManagement = $contentVersionManagement;
38 |     }
39 | 
40 |     /**
41 |      * @inheritDoc
42 |      */
43 |     public function execute(Observer $observer): void
44 |     {
45 |         $eventName = $observer->getEvent()->getName();
46 |         if (!array_key_exists($eventName, $this->eventsTypeMap)) {
47 |             return;
48 |         }
49 |         /** @var PageInterface|BlockInterface $cmsModel */
50 |         $cmsModel = $observer->getEvent()->getData('data_object');
51 |         $this->contentVersionManagement->deleteContentVersion(
52 |             $cmsModel->getIdentifier(),
53 |             $this->eventsTypeMap[$eventName],
54 |             $cmsModel->getStores()
55 |         );
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/Setup/Recurring.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Setup;
 6 | 
 7 | use Magento\Framework\Setup\InstallSchemaInterface;
 8 | use Magento\Framework\Setup\ModuleContextInterface;
 9 | use Magento\Framework\Setup\SchemaSetupInterface;
10 | use Overdose\CMSContent\Api\ContentVersionManagementInterface;
11 | 
12 | class Recurring implements InstallSchemaInterface
13 | {
14 |     /**
15 |      * @var ContentVersionManagementInterface
16 |      */
17 |     private $contentVersionManagement;
18 | 
19 |     /**
20 |      * @param ContentVersionManagementInterface $contentVersionManagement
21 |      */
22 |     public function __construct(ContentVersionManagementInterface $contentVersionManagement)
23 |     {
24 |         $this->contentVersionManagement = $contentVersionManagement;
25 |     }
26 | 
27 |     /**
28 |      * @inheritDoc
29 |      */
30 |     public function install(SchemaSetupInterface $setup, ModuleContextInterface $context)
31 |     {
32 |         $this->contentVersionManagement->processAll();
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Test/Unit/Controller/Adminhtml/History/ViewTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Test\Unit\Controller\Adminhtml\History;
 6 | 
 7 | use Magento\Backend\App\Action\Context;
 8 | use Magento\Framework\Controller\ResultFactory;
 9 | use Magento\Framework\View\Page\Config;
10 | use Magento\Framework\View\Page\Title;
11 | use Magento\Framework\View\Result\Page;
12 | use Overdose\CMSContent\Controller\Adminhtml\History\View;
13 | use PHPUnit\Framework\MockObject\MockObject;
14 | use PHPUnit\Framework\TestCase;
15 | 
16 | class ViewTest extends TestCase
17 | {
18 |     /**
19 |      * @var ResultFactory|MockObject
20 |      */
21 |     private $resultFactoryMock;
22 |     /**
23 |      * @var Config|MockObject
24 |      */
25 |     private $pageConfigMock;
26 |     /**
27 |      * @var Title|MockObject
28 |      */
29 |     private $pageTitleMock;
30 |     /**
31 |      * @var Context|MockObject
32 |      */
33 |     private $contextMock;
34 |     /**
35 |      * @var Page|MockObject
36 |      */
37 |     private $pageMock;
38 | 
39 |     /**
40 |      * Initialize test
41 |      */
42 |     public function setUp(): void
43 |     {
44 |         $this->resultFactoryMock = $this->getMockBuilder(ResultFactory::class)
45 |             ->disableOriginalConstructor()
46 |             ->getMock();
47 |         $this->pageMock = $this->getMockBuilder(Page::class)
48 |             ->disableOriginalConstructor()
49 |             ->getMock();
50 |         $this->pageConfigMock = $this->getMockBuilder(Config::class)
51 |             ->disableOriginalConstructor()
52 |             ->getMock();
53 |         $this->pageTitleMock = $this->getMockBuilder(Title::class)
54 |             ->disableOriginalConstructor()
55 |             ->getMock();
56 |         $this->contextMock = $this->getMockBuilder(Context::class)
57 |             ->disableOriginalConstructor()
58 |             ->getMock();
59 |     }
60 | 
61 |     public function testExecute()
62 |     {
63 |         $this->resultFactoryMock->expects($this->once())
64 |             ->method('create')
65 |             ->with(ResultFactory::TYPE_PAGE)
66 |             ->willReturn($this->pageMock);
67 |         $this->pageMock->expects($this->once())
68 |             ->method('getConfig')
69 |             ->willReturn($this->pageConfigMock);
70 |         $this->pageConfigMock->expects($this->once())
71 |             ->method('getTitle')
72 |             ->willReturn($this->pageTitleMock);
73 |         $this->pageTitleMock->expects($this->once())
74 |             ->method('prepend')
75 |             ->with('Backup Preview');
76 |         $this->contextMock->expects($this->once())
77 |             ->method('getResultFactory')
78 |             ->willReturn($this->resultFactoryMock);
79 | 
80 |         $controller = new View($this->contextMock);
81 |         $this->assertSame($this->pageMock, $controller->execute());
82 | 
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/Test/Unit/Controller/Adminhtml/Import/ImportTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Test\Unit\Controller\Adminhtml\Import;
  6 | 
  7 | use Magento\Backend\App\Action\Context;
  8 | use Magento\Framework\App\RequestInterface;
  9 | use Magento\Framework\Controller\Result\Redirect;
 10 | use Magento\Framework\Controller\Result\RedirectFactory;
 11 | use Magento\Framework\Message\ManagerInterface;
 12 | use Overdose\CMSContent\Api\ContentImportInterface;
 13 | use Overdose\CMSContent\Controller\Adminhtml\Import\Import;
 14 | use PHPUnit\Framework\MockObject\MockObject;
 15 | use PHPUnit\Framework\TestCase;
 16 | 
 17 | class ImportTest extends TestCase
 18 | {
 19 |     /**
 20 |      * @var RequestInterface|MockObject
 21 |      */
 22 |     private $requestMock;
 23 |     /**
 24 |      * @var ContentImportInterface|MockObject
 25 |      */
 26 |     private $importExportMock;
 27 |     /**
 28 |      * @var ManagerInterface|MockObject
 29 |      */
 30 |     private $messageManagerMock;
 31 |     /**
 32 |      * @var RedirectFactory|MockObject
 33 |      */
 34 |     private $redirectFactoryMock;
 35 |     /**
 36 |      * @var Redirect|MockObject
 37 |      */
 38 |     private $redirectMock;
 39 |     /**
 40 |      * @var Context|MockObject
 41 |      */
 42 |     private $contextMock;
 43 | 
 44 |     /**
 45 |      * Initialize test
 46 |      */
 47 |     public function setUp(): void
 48 |     {
 49 |         $this->requestMock = $this->getMockBuilder(RequestInterface::class)
 50 |             ->disableOriginalConstructor()
 51 |             ->getMockForAbstractClass();
 52 |         $this->importExportMock = $this->getMockBuilder(ContentImportInterface::class)
 53 |             ->disableOriginalConstructor()
 54 |             ->getMockForAbstractClass();
 55 |         $this->messageManagerMock = $this->getMockBuilder(ManagerInterface::class)
 56 |             ->disableOriginalConstructor()
 57 |             ->getMockForAbstractClass();
 58 |         $this->redirectFactoryMock = $this->getMockBuilder(RedirectFactory::class)
 59 |             ->disableOriginalConstructor()
 60 |             ->getMock();
 61 |         $this->redirectMock = $this->getMockBuilder(Redirect::class)
 62 |             ->disableOriginalConstructor()
 63 |             ->getMock();
 64 |         $this->contextMock = $this->getMockBuilder(Context::class)
 65 |             ->disableOriginalConstructor()
 66 |             ->getMock();
 67 |     }
 68 | 
 69 |     public function testExecute()
 70 |     {
 71 |         $upload[] = [
 72 |             'file' => 'filename',
 73 |             'path' => 'temppath'
 74 |         ];
 75 |         $cmsMode = ContentImportInterface::OD_CMS_MODE_UPDATE;
 76 |         $mediaMode = ContentImportInterface::OD_MEDIA_MODE_NONE;
 77 | 
 78 |         $this->requestMock->expects($this->atLeast(3))
 79 |             ->method('getParam')
 80 |             ->withConsecutive(['cms_import_mode'], ['media_import_mode'], ['upload'])
 81 |             ->willReturnOnConsecutiveCalls(
 82 |                 $cmsMode,
 83 |                 $mediaMode,
 84 |                 $upload
 85 |             );
 86 | 
 87 |         $this->importExportMock->expects($this->once())
 88 |             ->method('setCmsModeOption')
 89 |             ->with($cmsMode)
 90 |             ->willReturn($this->importExportMock);
 91 | 
 92 |         $this->importExportMock->expects($this->once())
 93 |             ->method('setMediaModeOption')
 94 |             ->with($mediaMode)
 95 |             ->willReturn($this->importExportMock);
 96 | 
 97 |         $this->importExportMock->expects($this->once())
 98 |             ->method('importContentFromZipFile')
 99 |             ->with($upload[0]['path'] . DIRECTORY_SEPARATOR . $upload[0]['file'], true)
100 |             ->willReturn(1);
101 | 
102 |         $this->messageManagerMock->expects($this->once())
103 |             ->method('addSuccessMessage');
104 | 
105 |         $this->redirectFactoryMock->expects($this->once())
106 |             ->method('create')
107 |             ->willReturn($this->redirectMock);
108 | 
109 |         $this->redirectMock->expects($this->once())
110 |             ->method('setPath')
111 |             ->with('*/*/index')
112 |             ->willReturnSelf();
113 | 
114 |         $this->contextMock->expects($this->once())
115 |             ->method('getRequest')
116 |             ->willReturn($this->requestMock);
117 | 
118 |         $this->contextMock->expects($this->once())
119 |             ->method('getMessageManager')
120 |             ->willReturn($this->messageManagerMock);
121 | 
122 |         $controller = new Import(
123 |             $this->contextMock,
124 |             $this->importExportMock,
125 |             $this->redirectFactoryMock
126 |         );
127 | 
128 |         $this->assertSame($this->redirectMock, $controller->execute());
129 |     }
130 | }
131 | 


--------------------------------------------------------------------------------
/Test/Unit/Controller/Adminhtml/Import/IndexTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Test\Unit\Controller\Adminhtml\Import;
  6 | 
  7 | use Magento\Backend\App\Action\Context;
  8 | use Magento\Backend\Model\View\Result\Page;
  9 | use Magento\Framework\Controller\ResultFactory;
 10 | use Magento\Framework\View\Page\Config;
 11 | use Magento\Framework\View\Page\Title;
 12 | use Overdose\CMSContent\Controller\Adminhtml\Import\Index;
 13 | use PHPUnit\Framework\MockObject\MockObject;
 14 | use PHPUnit\Framework\TestCase;
 15 | 
 16 | class IndexTest extends TestCase
 17 | {
 18 |     /**
 19 |      * @var ResultFactory|MockObject
 20 |      */
 21 |     private $resultFactoryMock;
 22 |     /**
 23 |      * @var Page|MockObject
 24 |      */
 25 |     private $resultPageMock;
 26 |     /**
 27 |      * @var Config|MockObject
 28 |      */
 29 |     private $pageConfigMock;
 30 |     /**
 31 |      * @var Title|MockObject
 32 |      */
 33 |     private $pageTitleMock;
 34 |     /**
 35 |      * @var Context|MockObject
 36 |      */
 37 |     private $contextMock;
 38 | 
 39 |     /**
 40 |      * Initialize test
 41 |      */
 42 |     public function setUp(): void
 43 |     {
 44 |         $this->resultFactoryMock = $this->getMockBuilder(ResultFactory::class)
 45 |             ->disableOriginalConstructor()
 46 |             ->getMock();
 47 |         $this->resultPageMock = $this->getMockBuilder(Page::class)
 48 |             ->disableOriginalConstructor()
 49 |             ->getMock();
 50 |         $this->pageConfigMock = $this->getMockBuilder(Config::class)
 51 |             ->disableOriginalConstructor()
 52 |             ->getMock();
 53 |         $this->pageTitleMock = $this->getMockBuilder(Title::class)
 54 |             ->disableOriginalConstructor()
 55 |             ->getMock();
 56 |         $this->contextMock = $this->getMockBuilder(Context::class)
 57 |             ->disableOriginalConstructor()
 58 |             ->getMock();
 59 |     }
 60 | 
 61 |     /**
 62 |      * @return void
 63 |      */
 64 |     public function testExecute()
 65 |     {
 66 |         $this->resultFactoryMock->expects($this->once())
 67 |             ->method('create')
 68 |             ->with(ResultFactory::TYPE_PAGE)
 69 |             ->willReturn($this->resultPageMock);
 70 | 
 71 |         $this->resultPageMock->expects($this->once())
 72 |             ->method('setActiveMenu')
 73 |             ->with('Overdose_CMSContent::import')
 74 |             ->willReturnSelf();
 75 | 
 76 |         $this->resultPageMock->expects($this->atLeast(2))
 77 |             ->method('addBreadcrumb')
 78 |             ->withConsecutive(['CMS', 'CMS'], ['Import CMS', 'Import CMS'])
 79 |             ->willReturnSelf();
 80 | 
 81 |         $this->resultPageMock->expects($this->atLeast(2))
 82 |             ->method('getConfig')
 83 |             ->willReturn($this->pageConfigMock);
 84 | 
 85 |         $this->pageConfigMock->expects($this->atLeast(2))
 86 |             ->method('getTitle')
 87 |             ->willReturn($this->pageTitleMock);
 88 | 
 89 |         $this->pageTitleMock->expects($this->atLeast(2))
 90 |             ->method('prepend')
 91 |             ->withConsecutive(['CMS'], ['CMS Import']);
 92 | 
 93 |         $this->contextMock->expects($this->once())
 94 |             ->method('getResultFactory')
 95 |             ->willReturn($this->resultFactoryMock);
 96 | 
 97 |         $controller = new Index($this->contextMock);
 98 | 
 99 |         $this->assertSame($this->resultPageMock, $controller->execute());
100 | 
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/Test/Unit/Controller/Adminhtml/Import/UploadTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Test\Unit\Controller\Adminhtml\Import;
  6 | 
  7 | use Magento\Framework\Controller\Result\Json;
  8 | use Magento\Framework\Controller\Result\JsonFactory;
  9 | use Magento\Framework\Message\ManagerInterface;
 10 | use Magento\MediaStorage\Model\File\Uploader;
 11 | use Magento\MediaStorage\Model\File\UploaderFactory;
 12 | use Overdose\CMSContent\Controller\Adminhtml\Import\Upload;
 13 | use Overdose\CMSContent\Model\Config;
 14 | use PHPUnit\Framework\MockObject\MockObject;
 15 | use PHPUnit\Framework\TestCase;
 16 | 
 17 | class UploadTest extends TestCase
 18 | {
 19 |     /**
 20 |      * @var JsonFactory|MockObject
 21 |      */
 22 |     private $resultJsonFactoryMock;
 23 |     /**
 24 |      * @var Json|MockObject
 25 |      */
 26 |     private $resultJsonMock;
 27 |     /**
 28 |      * @var UploaderFactory|MockObject
 29 |      */
 30 |     private $uploaderFactoryMock;
 31 |     /**
 32 |      * @var Config|MockObject
 33 |      */
 34 |     private $configMock;
 35 |     /**
 36 |      * @var ManagerInterface|MockObject
 37 |      */
 38 |     private $messageManagerMock;
 39 |     /**
 40 |      * @var Uploader|MockObject
 41 |      */
 42 |     private $uploaderMock;
 43 | 
 44 |     /**
 45 |      * Initialize test
 46 |      */
 47 |     public function setUp(): void
 48 |     {
 49 |         $this->resultJsonFactoryMock = $this->getMockBuilder(JsonFactory::class)
 50 |             ->disableOriginalConstructor()
 51 |             ->getMock();
 52 |         $this->resultJsonMock = $this->getMockBuilder(Json::class)
 53 |             ->disableOriginalConstructor()
 54 |             ->getMock();
 55 |         $this->configMock = $this->getMockBuilder(Config::class)
 56 |             ->disableOriginalConstructor()
 57 |             ->getMock();
 58 |         $this->uploaderFactoryMock = $this->getMockBuilder(UploaderFactory::class)
 59 |             ->disableOriginalConstructor()
 60 |             ->getMock();
 61 |         $this->uploaderMock = $this->getMockBuilder(Uploader::class)
 62 |             ->disableOriginalConstructor()
 63 |             ->getMock();
 64 |         $this->messageManagerMock = $this->getMockBuilder(ManagerInterface::class)
 65 |             ->disableOriginalConstructor()
 66 |             ->getMockForAbstractClass();
 67 |     }
 68 | 
 69 |     /**
 70 |      * @return void
 71 |      */
 72 |     public function testExecute()
 73 |     {
 74 |         $backupDir = '';
 75 | 
 76 |         $this->resultJsonFactoryMock->expects($this->once())
 77 |             ->method('create')
 78 |             ->willReturn($this->resultJsonMock);
 79 | 
 80 |         $this->resultJsonMock->expects($this->once())
 81 |             ->method('setData')
 82 |             ->with([])
 83 |             ->willReturnSelf();
 84 | 
 85 |         $this->uploaderFactoryMock->expects($this->once())
 86 |             ->method('create')
 87 |             ->with(['fileId' => 'upload'])
 88 |             ->willReturn($this->uploaderMock);
 89 | 
 90 |         $this->uploaderMock->expects($this->once())
 91 |             ->method('setAllowedExtensions')
 92 |             ->with(['zip'])
 93 |             ->willReturnSelf();
 94 | 
 95 |         $this->uploaderMock->expects($this->once())
 96 |             ->method('setAllowRenameFiles')
 97 |             ->with(true)
 98 |             ->willReturnSelf();
 99 | 
100 |         $this->uploaderMock->expects($this->once())
101 |             ->method('save')
102 |             ->with($backupDir . DIRECTORY_SEPARATOR . 'import')
103 |             ->willReturn([]);
104 | 
105 |         $this->configMock->expects($this->once())
106 |             ->method('getBackupsDir')
107 |             ->willReturn($backupDir);
108 | 
109 |         $controller = new Upload(
110 |             $this->configMock,
111 |             $this->resultJsonFactoryMock,
112 |             $this->uploaderFactoryMock,
113 |             $this->messageManagerMock
114 |         );
115 | 
116 |         $this->assertSame($this->resultJsonMock, $controller->execute());
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/Test/Unit/Model/BackupManagerTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Test\Unit\Model;
  6 | 
  7 | use Laminas\Json\Json;
  8 | use Magento\Cms\Model\Block;
  9 | use Magento\Cms\Model\Page;
 10 | use Magento\Framework\Filesystem\Driver\File;
 11 | use Overdose\CMSContent\File\FileManagerInterface;
 12 | use Overdose\CMSContent\Model\BackupManager;
 13 | use Overdose\CMSContent\Model\Config;
 14 | use PHPUnit\Framework\MockObject\MockObject;
 15 | use PHPUnit\Framework\TestCase;
 16 | use Psr\Log\LoggerInterface;
 17 | 
 18 | class BackupManagerTest extends TestCase
 19 | {
 20 |     /**
 21 |      * @var Config|MockObject
 22 |      */
 23 |     private $configMock;
 24 |     /**
 25 |      * @var FileManagerInterface|MockObject
 26 |      */
 27 |     private $fileMock;
 28 |     /**
 29 |      * @var File|MockObject
 30 |      */
 31 |     private $fileDriverMock;
 32 |     /**
 33 |      * @var Page|MockObject
 34 |      */
 35 |     private $cmsPageModelMock;
 36 |     /**
 37 |      * @var Block|MockObject
 38 |      */
 39 |     private $cmsBlockModelMock;
 40 |     /**
 41 |      * @var BackupManager
 42 |      */
 43 |     private $model;
 44 |     /**
 45 |      * @var Json
 46 |      */
 47 |     private Json $json;
 48 | 
 49 |     /**
 50 |      * Initialize test
 51 |      */
 52 |     public function setUp(): void
 53 |     {
 54 |         $this->configMock = $this->getMockBuilder(Config::class)
 55 |             ->disableOriginalConstructor()
 56 |             ->getMock();
 57 |         $this->fileMock = $this->getMockBuilder(FileManagerInterface::class)
 58 |             ->disableOriginalConstructor()
 59 |             ->getMock();
 60 |         $this->fileDriverMock = $this->getMockBuilder(File::class)
 61 |             ->disableOriginalConstructor()
 62 |             ->getMock();
 63 |         $this->loggerMock = $this->getMockBuilder(LoggerInterface::class)
 64 |             ->disableOriginalConstructor()
 65 |             ->getMock();
 66 |         $this->cmsBlockModelMock = $this->getMockBuilder(Block::class)
 67 |             ->disableOriginalConstructor()
 68 |             ->getMock();
 69 |         $this->cmsPageModelMock = $this->getMockBuilder(Page::class)
 70 |             ->disableOriginalConstructor()
 71 |             ->getMock();
 72 |         $this->json = new Json();
 73 | 
 74 |         $this->model = new BackupManager(
 75 |             $this->fileDriverMock,
 76 |             $this->fileMock,
 77 |             $this->configMock,
 78 |             $this->json,
 79 |             $this->loggerMock
 80 |         );
 81 |     }
 82 | 
 83 |     /**
 84 |      * @return void
 85 |      */
 86 |     public function testCreateBackupWithBlock()
 87 |     {
 88 |         $this->configMock->expects($this->once())
 89 |             ->method('isEnabled')
 90 |             ->willReturn(true);
 91 | 
 92 |         $this->fileMock->expects($this->once())
 93 |             ->method('writeData');
 94 | 
 95 |         $this->cmsBlockModelMock->expects($this->atLeastOnce())
 96 |             ->method('getStores')
 97 |             ->willReturn([0, 1]);
 98 | 
 99 |         $this->cmsBlockModelMock->expects($this->atLeastOnce())
100 |             ->method('getIdentifier')
101 |             ->willReturn('1');
102 | 
103 |         $this->cmsBlockModelMock->expects($this->atLeastOnce())
104 |             ->method('getOrigData')
105 |             ->withConsecutive(['title'], ['content'])
106 |             ->willReturnOnConsecutiveCalls('Lorem Ipsum Dolor Sit Amet.');
107 | 
108 |         $this->model->setCmsObject($this->cmsBlockModelMock);
109 |         $this->assertSame(
110 |             $this->model,
111 |             $this->model->createBackup('cms_block', $this->cmsBlockModelMock)
112 |         );
113 |     }
114 | 
115 |     /**
116 |      * @return void
117 |      */
118 |     public function testCreateBackupWithPage()
119 |     {
120 |         $this->configMock->expects($this->once())
121 |             ->method('isEnabled')
122 |             ->willReturn(true);
123 | 
124 |         $this->fileMock->expects($this->once())
125 |             ->method('writeData');
126 | 
127 |         $this->cmsPageModelMock->expects($this->atLeastOnce())
128 |             ->method('getStores')
129 |             ->willReturn([0, 1]);
130 | 
131 |         $this->cmsPageModelMock->expects($this->atLeastOnce())
132 |             ->method('getIdentifier')
133 |             ->willReturn('1');
134 | 
135 |         $this->cmsPageModelMock->expects($this->atLeastOnce())
136 |             ->method('getOrigData')
137 |             ->withConsecutive(['title'], ['content'])
138 |             ->willReturnOnConsecutiveCalls('Lorem Ipsum Dolor Sit Amet.');
139 | 
140 |         $this->model->setCmsObject($this->cmsPageModelMock);
141 |         $this->assertSame(
142 |             $this->model,
143 |             $this->model->createBackup('cms_page', $this->cmsPageModelMock)
144 |         );
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/Test/Unit/Model/Config/App/FileResolverTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Overdose\CMSContent\Test\Unit\Model\Config\App;
  4 | 
  5 | use Magento\Framework\Config\FileIterator;
  6 | use Magento\Framework\Config\FileIteratorFactory;
  7 | use Magento\Framework\Filesystem;
  8 | use Magento\Framework\Filesystem\Directory\ReadInterface;
  9 | use Overdose\CMSContent\Model\Config\App\FileResolver;
 10 | use Overdose\CMSContent\Model\Dir\Reader;
 11 | use PHPUnit\Framework\MockObject\MockObject;
 12 | use PHPUnit\Framework\TestCase;
 13 | 
 14 | class FileResolverTest extends TestCase
 15 | {
 16 |     /**
 17 |      * @var Reader|MockObject
 18 |      */
 19 |     private $readerMock;
 20 |     /**
 21 |      * @var Filesystem|MockObject
 22 |      */
 23 |     private $fileSystemMock;
 24 |     /**
 25 |      * @var FileIteratorFactory|MockObject
 26 |      */
 27 |     private $iteratorFactoryMock;
 28 |     /**
 29 |      * @var ReadInterface|MockObject
 30 |      */
 31 |     private $readInterfaceMock;
 32 |     /**
 33 |      * @var FileIterator|MockObject
 34 |      */
 35 |     private $fileIteratorMock;
 36 |     /**
 37 |      * @var FileResolver
 38 |      */
 39 |     private $sutObject;
 40 | 
 41 |     /**
 42 |      * Initialize test
 43 |      */
 44 |     public function setUp(): void
 45 |     {
 46 |         $this->readerMock = $this->getMockBuilder(Reader::class)
 47 |             ->disableOriginalConstructor()
 48 |             ->getMock();
 49 | 
 50 |         $this->fileSystemMock = $this->getMockBuilder(Filesystem::class)
 51 |             ->disableOriginalConstructor()
 52 |             ->getMock();
 53 | 
 54 |         $this->iteratorFactoryMock = $this->getMockBuilder(FileIteratorFactory::class)
 55 |             ->onlyMethods(['create'])
 56 |             ->disableOriginalConstructor()
 57 |             ->getMock();
 58 | 
 59 |         $this->readInterfaceMock = $this->getMockBuilder(ReadInterface::class)
 60 |             ->disableOriginalConstructor()
 61 |             ->getMock();
 62 | 
 63 |         $this->fileIteratorMock = $this->getMockBuilder(FileIterator::class)
 64 |             ->disableOriginalConstructor()
 65 |             ->getMock();
 66 | 
 67 |         $this->sutObject = new FileResolver(
 68 |             $this->readerMock,
 69 |             $this->fileSystemMock,
 70 |             $this->iteratorFactoryMock
 71 |         );
 72 |     }
 73 | 
 74 |     /**
 75 |      * @dataProvider dataProviderForGet
 76 |      * @param string $filename
 77 |      * @param string $scope
 78 |      */
 79 |     public function testGet($filename, $scope)
 80 |     {
 81 |         if ($scope == 'primary') {
 82 |             $this->fileSystemMock->expects($this->once())
 83 |                 ->method('getDirectoryRead')
 84 |                 ->willReturn($this->readInterfaceMock);
 85 | 
 86 |             $this->readInterfaceMock->expects($this->once())
 87 |                 ->method('search')
 88 |                 ->willReturn(['subFileOne', 'subFileTwo']);
 89 | 
 90 |             $this->readInterfaceMock->expects($this->exactly(2))
 91 |                 ->method('getAbsolutePath')
 92 |                 ->willReturnOnConsecutiveCalls(['absPathOne', 'absPathTwo']);
 93 | 
 94 |             $this->iteratorFactoryMock->expects($this->once())
 95 |                 ->method('create')
 96 |                 ->willReturn($this->fileIteratorMock);
 97 |         } else {
 98 |             $this->readerMock->expects($this->once())
 99 |                 ->method('getConfigurationFiles')
100 |                 ->willReturn($this->fileIteratorMock);
101 |         }
102 | 
103 |         $this->assertSame($this->fileIteratorMock, $this->sutObject->get($filename, $scope));
104 |     }
105 | 
106 |     /**
107 |      * Data provider for get method.
108 |      * @return string[][]
109 |      */
110 |     public function dataProviderForGet(): array
111 |     {
112 |         return [
113 |             'case_1_no_scope' => ['fileOne', ''],
114 |             'case_2_primary_scope' => ['fileTwo', 'primary'],
115 |             'case_3_global_scope' => ['fileThree', 'global']
116 |         ];
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/Test/Unit/Model/Config/ConverterAbstractTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Overdose\CMSContent\Test\Unit\Model\Config;
 4 | 
 5 | use DOMDocument;
 6 | use Overdose\CMSContent\Model\Config\Block\Converter;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class ConverterAbstractTest extends TestCase
10 | {
11 |     /**
12 |      * @var Converter
13 |      */
14 |     private $converterObject;
15 | 
16 |     /**
17 |      * Initialize test
18 |      */
19 |     public function setUp(): void
20 |     {
21 |         $this->converterObject = new Converter();
22 |     }
23 | 
24 |     /**
25 |      * @dataProvider dataProviderForConvert
26 |      */
27 |     public function testConvert($xmlContent)
28 |     {
29 |         $domDocument = new DOMDocument();
30 |         $domDocument->loadXML($xmlContent);
31 | 
32 |         $result = $this->converterObject->convert($domDocument);
33 |         $expected = [
34 |             'some-identifier_0' => [
35 |                 'identifier' => 'some-identifier',
36 |                 'title' => 'Some block title',
37 |                 'content' => '<div>Content here</div>',
38 |                 'version' => '1.0.0',
39 |                 'is_active' => '1',
40 |                 'store_ids' => ''
41 |             ],
42 |             'some-identifier-2_1_2_3' => [
43 |                 'identifier' => 'some-identifier-2',
44 |                 'title' => 'Some block title 2',
45 |                 'content' => '<div>Content here 2</div>',
46 |                 'version' => '1.0.1',
47 |                 'is_active' => '1',
48 |                 'store_ids' => '1,2,3'
49 |             ]
50 |         ];
51 | 
52 |         $this->assertSame($expected, $result);
53 |     }
54 | 
55 |     /**
56 |      * data provider for convert function. The xmlContent value is hardcoded and taken from sample cms_block_data.xml
57 |      * file present in etc/od_cms directory.
58 |      * @return string[][]
59 |      */
60 |     public function dataProviderForConvert(): array
61 |     {
62 |         $xmlContent = '<?xml version="1.0"?><config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="cms_block_data.xsd"><cms_blocks><cms_block identifier="some-identifier"><attribute code="title">Some block title</attribute><attribute code="content"><![CDATA[<div>Content here</div>]]></attribute><attribute code="version">1.0.0</attribute><attribute code="is_active">1</attribute><attribute code="store_ids"/></cms_block><cms_block identifier="some-identifier-2"><attribute code="title">Some block title 2</attribute><attribute code="content"><![CDATA[<div>Content here 2</div>]]></attribute><attribute code="version">1.0.1</attribute><attribute code="is_active">1</attribute><attribute code="store_ids">1,2,3</attribute></cms_block></cms_blocks></config>';
63 |         return [[$xmlContent]];
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/Test/Unit/Model/ConfigTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Test\Unit\Model;
  6 | 
  7 | use Overdose\CMSContent\Model\Config;
  8 | use Magento\Framework\App\Config\ScopeConfigInterface;
  9 | use Magento\Framework\App\Filesystem\DirectoryList;
 10 | use PHPUnit\Framework\MockObject\MockObject;
 11 | use PHPUnit\Framework\TestCase;
 12 | 
 13 | class ConfigTest extends TestCase
 14 | {
 15 |     /**
 16 |      * @var DirectoryList|MockObject
 17 |      */
 18 |     protected $directoryList;
 19 | 
 20 |     /**
 21 |      * @var ScopeConfigInterface|MockObject
 22 |      */
 23 |     protected $scopeConfig;
 24 | 
 25 |     /**
 26 |      * Initialize test
 27 |      */
 28 |     protected function setUp(): void
 29 |     {
 30 |         $this->scopeConfig = $this->createMock(ScopeConfigInterface::class);
 31 |         $this->directoryList = $this->createMock(DirectoryList::class);
 32 | 
 33 |         $this->config = $this->createMock(Config::class);
 34 |     }
 35 | 
 36 |     /**
 37 |      * Test getBackupsDir
 38 |      *
 39 |      * @return void
 40 |      */
 41 |     public function testGetBackupsDir()
 42 |     {
 43 |         $this->directoryList->expects($this->once())
 44 |             ->method('getPath')
 45 |             ->willReturn('var');
 46 | 
 47 |         $config = new Config(
 48 |             $this->scopeConfig,
 49 |             $this->directoryList
 50 |         );
 51 | 
 52 |         $result = $config->getBackupsDir();
 53 | 
 54 |         $expected = 'var' . DIRECTORY_SEPARATOR . Config::CMS_DIR;
 55 | 
 56 |         $this->assertEquals($expected, $result);
 57 |     }
 58 | 
 59 |     /**
 60 |      * Test getExportPath
 61 |      *
 62 |      * @return void
 63 |      */
 64 |     public function testGetExportPath()
 65 |     {
 66 |         $this->directoryList->expects($this->once())
 67 |             ->method('getPath')
 68 |             ->willReturn('var');
 69 | 
 70 |         $config = new Config(
 71 |             $this->scopeConfig,
 72 |             $this->directoryList
 73 |         );
 74 | 
 75 |         $result = $config->getExportPath();
 76 | 
 77 |         $expected = 'var' . DIRECTORY_SEPARATOR . Config::CMS_DIR . DIRECTORY_SEPARATOR . Config::EXPORT_PATH;
 78 | 
 79 |         $this->assertEquals($expected, $result);
 80 |     }
 81 | 
 82 |     /**
 83 |      * Test getExtractPath
 84 |      *
 85 |      * @return void
 86 |      */
 87 |     public function testGetExtractPath()
 88 |     {
 89 |         $this->directoryList->expects($this->once())
 90 |             ->method('getPath')
 91 |             ->willReturn('var');
 92 | 
 93 |         $config = new Config(
 94 |             $this->scopeConfig,
 95 |             $this->directoryList
 96 |         );
 97 | 
 98 |         $result = $config->getExtractPath();
 99 | 
100 |         $expected = 'var' . DIRECTORY_SEPARATOR . Config::CMS_DIR . DIRECTORY_SEPARATOR . Config::EXTRACT_PATH;
101 | 
102 |         $this->assertEquals($expected, $result);
103 |     }
104 | }
105 | 


--------------------------------------------------------------------------------
/Test/Unit/Model/Service/ClearCMSHistoryTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Model\Service;
  6 | 
  7 | /**
  8 |  * Override filemtime() in the Overdose\CMSContent\Model\Service namespace when testing
  9 |  *
 10 |  * @return int
 11 |  */
 12 | function filemtime()
 13 | {
 14 |     return 123;
 15 | }
 16 | 
 17 | namespace Overdose\CMSContent\Test\Unit\Model\Service;
 18 | 
 19 | use Magento\Framework\Filesystem\Driver\File;
 20 | use Magento\Framework\Stdlib\DateTime\DateTime;
 21 | use Overdose\CMSContent\Model\Config;
 22 | use Overdose\CMSContent\Model\Service\ClearCMSHistory;
 23 | use PHPUnit\Framework\MockObject\MockObject;
 24 | use PHPUnit\Framework\TestCase;
 25 | use Psr\Log\LoggerInterface;
 26 | 
 27 | class ClearCMSHistoryTest extends TestCase
 28 | {
 29 |     /**
 30 |      * @var File|MockObject
 31 |      */
 32 |     private $fileMock;
 33 |     /**
 34 |      * @var ClearCMSHistory|MockObject
 35 |      */
 36 |     private $serviceModel;
 37 |     /**
 38 |      * @var DateTime|MockObject
 39 |      */
 40 |     private $dateTimeMock;
 41 |     /**
 42 |      * @var Config|MockObject
 43 |      */
 44 |     private $configMock;
 45 |     /**
 46 |      * @var MockObject|LoggerInterface
 47 |      */
 48 |     private $loggerInterfaceMock;
 49 | 
 50 |     /**
 51 |      * Initialize test
 52 |      */
 53 |     public function setUp(): void
 54 |     {
 55 |         $this->fileMock = $this->getMockBuilder(File::class)
 56 |             ->disableOriginalConstructor()
 57 |             ->getMock();
 58 |         $this->dateTimeMock = $this->getMockBuilder(DateTime::class)
 59 |             ->disableOriginalConstructor()
 60 |             ->getMock();
 61 |         $this->configMock = $this->getMockBuilder(Config::class)
 62 |             ->disableOriginalConstructor()
 63 |             ->getMock();
 64 |         $this->loggerInterfaceMock = $this->getMockBuilder(LoggerInterface::class)
 65 |             ->disableOriginalConstructor()
 66 |             ->getMock();
 67 | 
 68 |         $this->serviceModel = new ClearCMSHistory(
 69 |             $this->dateTimeMock,
 70 |             $this->configMock,
 71 |             $this->loggerInterfaceMock,
 72 |             $this->fileMock
 73 |         );
 74 |     }
 75 | 
 76 |     /**
 77 |      * Test clear action by providing two files in mock objects and expecting count of two returned in result.
 78 |      * @return void
 79 |      * @throws \Magento\Framework\Exception\FileSystemException
 80 |      */
 81 |     public function testExecute()
 82 |     {
 83 |         $outerDirs = ['parentOne', 'parentTwo'];
 84 |         $files = ['fileOne', 'fileTwo'];
 85 | 
 86 |         $this->fileMock->expects($this->atLeastOnce())
 87 |             ->method('readDirectory')
 88 |             ->willReturnOnConsecutiveCalls($outerDirs, $files, $files, $files, $files);
 89 | 
 90 |         $this->fileMock->expects($this->atLeastOnce())
 91 |             ->method('isFile')
 92 |             ->willReturn(true);
 93 | 
 94 |         $this->configMock->expects($this->atLeastOnce())
 95 |             ->method('getBackupsDir')
 96 |             ->willReturn('');
 97 | 
 98 |         $this->configMock->expects($this->atLeastOnce())
 99 |             ->method('getMethodType')
100 |             ->willReturn(Config::PERIOD);
101 | 
102 |         $this->dateTimeMock->expects($this->atLeastOnce())
103 |             ->method('gmtTimestamp')
104 |             ->willReturn(1659355018);
105 | 
106 |         $this->assertEquals(2, $this->serviceModel->execute(Config::TYPE_BLOCK));
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/Test/Unit/Model/StoreManagementTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Test\Unit\Model;
  6 | 
  7 | use Magento\Store\Api\Data\StoreInterface;
  8 | use Magento\Store\Api\StoreRepositoryInterface;
  9 | use Overdose\CMSContent\Model\StoreManagement;
 10 | use PHPUnit\Framework\MockObject\MockObject;
 11 | use PHPUnit\Framework\TestCase;
 12 | 
 13 | class StoreManagementTest extends TestCase
 14 | {
 15 |     /**
 16 |      * @var StoreRepositoryInterface|MockObject
 17 |      */
 18 |     private $storeRepositoryMock;
 19 |     /**
 20 |      * @var StoreInterface|MockObject
 21 |      */
 22 |     private $storeInterfaceMock;
 23 |     /**
 24 |      * @var StoreManagement
 25 |      */
 26 |     private $model;
 27 | 
 28 |     /**
 29 |      * Initialize test
 30 |      */
 31 |     public function setUp(): void
 32 |     {
 33 |         $this->storeRepositoryMock = $this->getMockBuilder(StoreRepositoryInterface::class)
 34 |             ->disableOriginalConstructor()
 35 |             ->getMock();
 36 |         $this->storeInterfaceMock = $this->getMockBuilder(StoreInterface::class)
 37 |             ->disableOriginalConstructor()
 38 |             ->getMock();
 39 |         $this->model = new StoreManagement(
 40 |             $this->storeRepositoryMock
 41 |         );
 42 |     }
 43 | 
 44 |     /**
 45 |      * @return array
 46 |      */
 47 |     public function dataProviderGetStoreIdsByCodes(): array
 48 |     {
 49 |         return [
 50 |             'store_not_found_case' => [
 51 |                 'storeCodes' => ['us'],
 52 |                 'expectedResult' => []
 53 |             ],
 54 |             'store_found_case' => [
 55 |                 'storeCodes' => ['nz'],
 56 |                 'expectedResult' => [1]
 57 |             ],
 58 |             'admin_case' => [
 59 |                 'storeCodes' => ['admin'],
 60 |                 'expectedResult' => [0]
 61 |             ],
 62 |             'multi_store_case' => [
 63 |                 'storeCodes' => ['admin', 'nz', 'us', 'au'],
 64 |                 'expectedResult' => [0, 1, 2]
 65 |             ]
 66 |         ];
 67 |     }
 68 | 
 69 |     /**
 70 |      * @dataProvider dataProviderGetStoreIdsByCodes
 71 |      * @return void
 72 |      */
 73 |     public function testGetStoreIdsByCodes($storeCodes, $expectedResult)
 74 |     {
 75 |         $this->storeInterfaceMock
 76 |             ->method('getId')
 77 |             ->willReturn(1);
 78 | 
 79 |         $auStore = $this->getMockBuilder(StoreInterface::class)
 80 |             ->disableOriginalConstructor()
 81 |             ->getMock();
 82 |         $auStore->method('getId')
 83 |             ->willReturn(2);
 84 | 
 85 |         $this->storeRepositoryMock
 86 |             ->method('get')
 87 |             ->withConsecutive(['nz'], ['au'])
 88 |             ->willReturnOnConsecutiveCalls($this->storeInterfaceMock, $auStore);
 89 | 
 90 |         $this->storeRepositoryMock->expects($this->atLeastOnce())
 91 |             ->method('getList')
 92 |             ->willReturn(['admin' => 'adminStore', 'nz' => 'nzStore', 'au' => 'auStore']);
 93 | 
 94 |         $this->assertEquals($expectedResult, $this->model->getStoreIdsByCodes($storeCodes));
 95 |     }
 96 | 
 97 |     /**
 98 |      * @return array
 99 |      */
100 |     public function dataProviderFilterStoresByStoreCodes(): array
101 |     {
102 |         return [
103 |             'store_not_found_case' => [
104 |                 'storeCodes' => ['pk'],
105 |                 'expectedResult' => []
106 |             ],
107 |             'store_found_case' => [
108 |                 'storeCodes' => ['nz'],
109 |                 'expectedResult' => ['nz']
110 |             ],
111 |             'admin_case' => [
112 |                 'storeCodes' => ['admin'],
113 |                 'expectedResult' => ['admin']
114 |             ],
115 |             'multi_store_case' => [
116 |                 'storeCodes' => ['admin', 'au', 'nz', 'ua'],
117 |                 'expectedResult' => ['admin', 'nz']
118 |             ]
119 |         ];
120 |     }
121 | 
122 |     /**
123 |      * @dataProvider dataProviderFilterStoresByStoreCodes
124 |      * @return void
125 |      */
126 |     public function testFilterStoresByStoreCodes($storeCodes, $expectedResult)
127 |     {
128 |         $this->storeRepositoryMock->expects($this->once())
129 |             ->method('getList')
130 |             ->willReturn(['admin' => 'adminStore', 'nz' => 'nzStore']);
131 | 
132 |         $this->assertSame($expectedResult, $this->model->filterStoresByStoreCodes($storeCodes));
133 |     }
134 | 
135 |     /**
136 |      * @return array
137 |      */
138 |     public function dataProviderFilterStoresByStoreIds(): array
139 |     {
140 |         return [
141 |             'store_not_found_case' => [
142 |                 'storeIds' => [77],
143 |                 'expectedResult' => []
144 |             ],
145 |             'store_found_case' => [
146 |                 'storeIds' => [1],
147 |                 'expectedResult' => [1]
148 |             ],
149 |             'admin_case' => [
150 |                 'storeIds' => [0],
151 |                 'expectedResult' => [0]
152 |             ],
153 |             'multi_store_case' => [
154 |                 'storeIds' => [0, 1, 2, 77],
155 |                 'expectedResult' => [0, 1, 2]
156 |             ]
157 |         ];
158 |     }
159 | 
160 |     /**
161 |      * @dataProvider dataProviderFilterStoresByStoreIds
162 |      * @return void
163 |      */
164 |     public function testFilterStoresByStoreIds($storeIds, $expectedResult)
165 |     {
166 |         $adminStore = $this->getMockBuilder(StoreInterface::class)
167 |             ->disableOriginalConstructor()
168 |             ->getMock();
169 |         $adminStore->expects($this->atLeastOnce())
170 |             ->method('getId')
171 |             ->willReturn(0);
172 | 
173 |         $nzStore = $this->getMockBuilder(StoreInterface::class)
174 |             ->disableOriginalConstructor()
175 |             ->getMock();
176 |         $nzStore->expects($this->atLeastOnce())
177 |             ->method('getId')
178 |             ->willReturn(1);
179 | 
180 |         $auStore = $this->getMockBuilder(StoreInterface::class)
181 |             ->disableOriginalConstructor()
182 |             ->getMock();
183 |         $auStore->expects($this->atLeastOnce())
184 |             ->method('getId')
185 |             ->willReturn(2);
186 | 
187 |         $this->storeRepositoryMock->expects($this->atLeastOnce())
188 |             ->method('getList')
189 |             ->willReturn(['admin' => $adminStore, 'nz' => $nzStore, 'au' => $auStore]);
190 | 
191 |         $this->assertSame($expectedResult, $this->model->filterStoresByStoreIds($storeIds));
192 |     }
193 | }
194 | 


--------------------------------------------------------------------------------
/Test/Unit/Observer/CmsSaveBeforeTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Test\Unit\Observer;
  6 | 
  7 | use Magento\Framework\Model\AbstractModel;
  8 | use Overdose\CMSContent\Observer\CmsSaveBefore;
  9 | use PHPUnit\Framework\MockObject\MockObject;
 10 | use PHPUnit\Framework\TestCase;
 11 | 
 12 | class CmsSaveBeforeTest extends TestCase
 13 | {
 14 |     /**
 15 |      * @var CmsSaveBefore|MockObject
 16 |      */
 17 |     protected $cmsSaveBefore;
 18 | 
 19 |     /**
 20 |      * Initialize test
 21 |      */
 22 |     protected function setUp(): void
 23 |     {
 24 |         /**
 25 |          * Init mock for CancelStuckOrders
 26 |          */
 27 |         $this->cmsSaveBefore = $this->getMockBuilder(CmsSaveBefore::class)
 28 |             ->disableOriginalConstructor(true)
 29 |             ->getMock();
 30 |     }
 31 | 
 32 |     /**
 33 |      * Test function: HasImportantDataChanges
 34 |      *
 35 |      * @param $cmsEntity
 36 |      * @param bool $expected
 37 |      * @dataProvider formHasImportantDataChangesProvider
 38 |      *
 39 |      * @return void
 40 |      * @throws \ReflectionException
 41 |      */
 42 |     public function testHasImportantDataChanges($cmsEntity, bool $expected)
 43 |     {
 44 |         $result = $this->invokeMethod(
 45 |             $this->cmsSaveBefore,
 46 |             'hasImportantDataChanges',
 47 |             [
 48 |                 $cmsEntity
 49 |             ]
 50 |         );
 51 | 
 52 |         $this->assertEquals($expected, $result);
 53 |     }
 54 | 
 55 |     /**
 56 |      * Provider testHasImportantDataChanges
 57 |      *
 58 |      * @return array
 59 |      */
 60 |     public function formHasImportantDataChangesProvider(): array
 61 |     {
 62 |         $testCases = [];
 63 | 
 64 |         $dataModel = $this->getMockBuilder(AbstractModel::class)
 65 |             ->disableOriginalConstructor()
 66 |             ->getMockForAbstractClass();
 67 | 
 68 |         $dataModelCase1 = clone $dataModel;
 69 |         $dataModelCase1->setData([
 70 |             'identifier' => 'no-route',
 71 |             'title' => 'no-route',
 72 |             'content' => 'no-route',
 73 |             'content_heading' => 'no-route',
 74 |         ]);
 75 |         $dataModelCase1->setOrigData('identifier', 'no-route');
 76 |         $dataModelCase1->setOrigData('title', 'no-route');
 77 |         $dataModelCase1->setOrigData('content', 'no-route');
 78 |         $dataModelCase1->setOrigData('content_heading', 'no-route');
 79 | 
 80 |         $testCases['case_1_true'] = [
 81 |             'cmsEntity' => $dataModelCase1,
 82 |             'expected' => false
 83 |         ];
 84 | 
 85 |         $dataModelCase2 = clone $dataModel;
 86 |         $dataModelCase2->setData([
 87 |             'identifier' => 'no-route2',
 88 |             'title' => 'no-route',
 89 |             'content' => 'no-route',
 90 |             'content_heading' => 'no-route',
 91 |         ]);
 92 |         $dataModelCase2->setOrigData('identifier', 'no-route');
 93 |         $dataModelCase2->setOrigData('title', 'no-route');
 94 |         $dataModelCase2->setOrigData('content', 'no-route');
 95 |         $dataModelCase2->setOrigData('content_heading', 'no-route');
 96 | 
 97 |         $testCases['case_2_false'] = [
 98 |             'cmsEntity' => $dataModelCase2,
 99 |             'expected' => true
100 |         ];
101 | 
102 |         $dataModelCase3 = clone $dataModel;
103 |         $dataModelCase3->setData([
104 |             'identifier' => 'no-route2',
105 |             'title' => 'no-route',
106 |             'content' => 'no-route',
107 |             'content_heading' => 'no-route',
108 |         ]);
109 | 
110 |         $testCases['case_3_false'] = [
111 |             'cmsEntity' => $dataModelCase3,
112 |             'expected' => false
113 |         ];
114 | 
115 |         return $testCases;
116 |     }
117 | 
118 |     /**
119 |      * Invoke private method
120 |      *
121 |      * @param $object
122 |      * @param $methodName
123 |      * @param array $parameters
124 |      *
125 |      * @return mixed
126 |      * @throws \ReflectionException
127 |      */
128 |     protected function invokeMethod(&$object, $methodName, array $parameters = [])
129 |     {
130 |         $reflection = new \ReflectionClass(get_class($object));
131 |         $method = $reflection->getMethod($methodName);
132 |         $method->setAccessible(true);
133 | 
134 |         return $method->invokeArgs($object, $parameters);
135 |     }
136 | }
137 | 


--------------------------------------------------------------------------------
/Ui/DataProvider/HistoryView.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Overdose\CMSContent\Ui\DataProvider;
  6 | 
  7 | use Laminas\Json\Json;
  8 | use Magento\Framework\Api\Filter;
  9 | use Magento\Framework\App\RequestInterface;
 10 | use Magento\Ui\DataProvider\AbstractDataProvider;
 11 | use Overdose\CMSContent\File\FileManagerInterface;
 12 | use Overdose\CMSContent\Model\BackupManager;
 13 | 
 14 | class HistoryView extends AbstractDataProvider
 15 | {
 16 |     /**
 17 |      * @var BackupManager
 18 |      */
 19 |     private $backupManager;
 20 | 
 21 |     /**
 22 |      * @var FileManagerInterface
 23 |      */
 24 |     private $file;
 25 | 
 26 |     /**
 27 |      * @var RequestInterface
 28 |      */
 29 |     private $request;
 30 | 
 31 |     /**
 32 |      * @var Json
 33 |      */
 34 |     private $jsonFormatter;
 35 | 
 36 |     /**
 37 |      * Constructor
 38 |      *
 39 |      * @param string $name
 40 |      * @param string $primaryFieldName
 41 |      * @param string $requestFieldName
 42 |      * @param RequestInterface $request
 43 |      * @param BackupManager $backupManager
 44 |      * @param Json $jsonFormatter
 45 |      * @param FileManagerInterface $file
 46 |      * @param array $meta
 47 |      * @param array $data
 48 |      */
 49 |     public function __construct(
 50 |         $name,
 51 |         $primaryFieldName,
 52 |         $requestFieldName,
 53 |         RequestInterface $request,
 54 |         BackupManager $backupManager,
 55 |         Json $jsonFormatter,
 56 |         FileManagerInterface $file,
 57 |         array $meta = [],
 58 |         array $data = []
 59 |     ) {
 60 |         parent::__construct(
 61 |             $name,
 62 |             $primaryFieldName,
 63 |             $requestFieldName,
 64 |             $meta,
 65 |             $data
 66 |         );
 67 |         $this->backupManager = $backupManager;
 68 |         $this->jsonFormatter = $jsonFormatter;
 69 |         $this->file = $file;
 70 |         $this->request = $request;
 71 |     }
 72 | 
 73 |     /**
 74 |      * Get data
 75 |      *
 76 |      * @return array
 77 |      */
 78 |     public function getData(): array
 79 |     {
 80 |         $data = [];
 81 |         if ($backupItemIdentifier = $this->request->getParam('bc_identifier')) {
 82 |             $parsedArray = $this->jsonFormatter->decode($this->getBackupContent(), true);
 83 |             $data[$backupItemIdentifier] = [
 84 |                 'identifier' => $parsedArray['identifier'] ?? '',
 85 |                 'title' => $parsedArray['title'] ?? '',
 86 |                 'content' => $parsedArray['content'] ?? ''
 87 |             ];
 88 |         }
 89 | 
 90 |         return $data;
 91 |     }
 92 | 
 93 |     /**
 94 |      * Retrieve content from backup
 95 |      *
 96 |      * @return mixed
 97 |      */
 98 |     public function getBackupContent()
 99 |     {
100 |         $itemIdentifier = $this->request->getParam('bc_identifier');
101 |         $itemName = $this->request->getParam('item');
102 |         $itemType = $this->request->getParam('bc_type');
103 |         $storeId  = $this->request->getParam('store_id');
104 | 
105 |         if (!is_null($storeId)) {
106 |             $path = $this->backupManager->getBackupPathByStoreId($itemType, $itemIdentifier, (int)$storeId)
107 |                 . DIRECTORY_SEPARATOR . $itemName;
108 |         } else {
109 |             $path = $this->backupManager->getBackupPath($itemType, $itemIdentifier)
110 |                 . DIRECTORY_SEPARATOR . $itemName;
111 |         }
112 | 
113 |         return $this->file->readData($path);
114 |     }
115 | 
116 |     /**
117 |      * @inheritDoc
118 |      */
119 |     public function addFilter(Filter $filter)
120 |     {
121 |         return $this;
122 |     }
123 | }
124 | 


--------------------------------------------------------------------------------
/Ui/DataProvider/Import.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Overdose\CMSContent\Ui\DataProvider;
 6 | 
 7 | use Magento\Ui\DataProvider\AbstractDataProvider;
 8 | use Magento\Framework\Api\Filter;
 9 | 
10 | class Import extends AbstractDataProvider
11 | {
12 |     /**
13 |      * We can provide prefill data this way
14 |      *
15 |      * @return array
16 |      */
17 |     public function getData(): array
18 |     {
19 |         return [];
20 |     }
21 | 
22 |     /**
23 |      * @inheritDoc
24 |      */
25 |     public function addFilter(Filter $filter)
26 |     {
27 |         return $this;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "overdose/module-cmscontent",
 3 |     "description": "Static content update and backups",
 4 |     "type": "magento2-module",
 5 |     "license": "proprietary",
 6 |     "authors": [
 7 |         {
 8 |             "name": "Overdose",
 9 |             "email": "hello@overdose.digital"
10 |         }
11 |     ],
12 |     "require": {
13 |         "magento/framework": ">=102.0",
14 |         "overdose/module-core": "*"
15 |     },
16 |     "autoload": {
17 |         "psr-4": {
18 |             "Overdose\\CMSContent\\": ""
19 |         },
20 |         "files": [
21 |             "registration.php"
22 |         ]
23 |     },
24 |     "version": "2.0.5"
25 | }
26 | 


--------------------------------------------------------------------------------
/etc/acl.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Acl/etc/acl.xsd">
 3 |     <acl>
 4 |         <resources>
 5 |             <resource id="Magento_Backend::admin">
 6 |                 <resource id="Magento_Backend::stores">
 7 |                     <resource id="Magento_Backend::stores_settings">
 8 |                         <resource id="Magento_Config::config">
 9 |                             <resource id="Overdose_CMSContent::config_overdose_cmscontent" title="cms_content"/>
10 |                         </resource>
11 |                     </resource>
12 |                     <resource id="Overdose_CMSContent::cmscontent" sortOrder="10" title="cmscontent">
13 |                         <resource id="Overdose_CMSContent::history_view" sortOrder="10" title="history view"/>
14 |                     </resource>
15 |                 </resource>
16 |                 <resource id="Magento_Backend::content">
17 |                     <resource id="Magento_Backend::content_elements">
18 |                         <resource id="Magento_Cms::page" title="Pages" sortOrder="10">
19 |                             <resource id="Overdose_CMSContent::export_page" title="Export Page" sortOrder="10" />
20 |                         </resource>
21 |                         <resource id="Magento_Cms::block" title="Blocks" sortOrder="20">
22 |                             <resource id="Overdose_CMSContent::export_block" title="Export Blocks" sortOrder="10" />
23 |                         </resource>
24 |                         <resource id="Overdose_CMSContent::import" title="Import" sortOrder="30" />
25 |                     </resource>
26 |                 </resource>
27 |             </resource>
28 |         </resources>
29 |     </acl>
30 | </config>
31 | 


--------------------------------------------------------------------------------
/etc/adminhtml/events.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Event/etc/events.xsd">
 3 |     <event name="cms_block_save_before">
 4 |         <observer instance="Overdose\CMSContent\Observer\CmsSaveBefore"
 5 |                   name="od-cmscontent_observer_cms_blocksavebefore_cms_block_save_before"/>
 6 |     </event>
 7 |     <event name="cms_page_save_before">
 8 |         <observer instance="Overdose\CMSContent\Observer\CmsSaveBefore"
 9 |                   name="od-cmscontent_observer_cms_pagesavebefore_cms_page_save_before"/>
10 |     </event>
11 |     <event name="cms_page_delete_commit_after">
12 |         <observer instance="Overdose\CMSContent\Observer\DeleteContentVersion"
13 |                   name="od-cmscontent_cms_page_delete_after"/>
14 |     </event>
15 |     <event name="cms_block_delete_commit_after">
16 |         <observer instance="Overdose\CMSContent\Observer\DeleteContentVersion"
17 |                   name="od-cmscontent_cms_block_delete_after" />
18 |     </event>
19 | </config>
20 | 


--------------------------------------------------------------------------------
/etc/adminhtml/menu.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Backend:etc/menu.xsd">
 3 |     <menu>
 4 |         <add id="Overdose_CMSContent::import"
 5 |              title="Import"
 6 |              module="Overdose_CMSContent"
 7 |              sortOrder="9999"
 8 |              parent="Magento_Backend::content_elements"
 9 |              action="cmscontent/import"
10 |              resource="Overdose_CMSContent::import"/>
11 |     </menu>
12 | </config>
13 | 


--------------------------------------------------------------------------------
/etc/adminhtml/routes.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" ?>
2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:App/etc/routes.xsd">
3 |     <router id="admin">
4 |         <route frontName="cmscontent" id="cmscontent">
5 |             <module before="Magento_Backend" name="Overdose_CMSContent"/>
6 |         </route>
7 |     </router>
8 | </config>
9 | 


--------------------------------------------------------------------------------
/etc/adminhtml/system.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Config:etc/system_file.xsd">
 3 |     <system>
 4 |         <section id="cms_content" showInDefault="1" showInStore="1" showInWebsite="1" sortOrder="100" translate="label">
 5 |             <label>Cms Content</label>
 6 |             <tab>od_core</tab>
 7 |             <resource>Overdose_CMSContent::config_overdose_cmscontent</resource>
 8 |             <group id="general" showInDefault="1" showInStore="1" showInWebsite="1" sortOrder="10" translate="label">
 9 |                 <label>General</label>
10 |                 <field id="enabled" showInDefault="1" showInStore="0" showInWebsite="0" sortOrder="10" translate="label" type="select">
11 |                     <label>Enabled</label>
12 |                     <comment/>
13 |                     <source_model>Magento\Config\Model\Config\Source\Yesno</source_model>
14 |                 </field>
15 |             </group>
16 | 
17 |             <group id="backups" translate="label" type="text" sortOrder="20" showInDefault="1" showInWebsite="1" showInStore="1">
18 |                 <label>Backups</label>
19 |                 <group id="delete" showInDefault="1" showInStore="1" showInWebsite="1" sortOrder="20" translate="label">
20 |                     <label>Delete Backups</label>
21 |                     <field id="cron_enabled" showInDefault="1" showInStore="1" showInWebsite="1" sortOrder="10" translate="label comment" type="select">
22 |                         <label>Enabled</label>
23 |                         <comment>In case enabled: old backups will be deleted by cron according to selected deleting method.</comment>
24 |                         <source_model>Magento\Config\Model\Config\Source\Yesno</source_model>
25 |                     </field>
26 |                     <field id="method" translate="label" type="select" sortOrder="10" showInDefault="1" showInStore="1" showInWebsite="1">
27 |                         <label>Delete Method</label>
28 |                         <source_model>Overdose\CMSContent\Model\OptionSource\Methods</source_model>
29 |                         <comment><![CDATA[
30 |                        <p><b>By Periods</b>: Left one file per a period (weeks, months and years):<br/>
31 |                            - One history item per year for older than year.<br/>
32 |                            - One history item per month for older than month but yonger 12m.<br/>
33 |                            - One history item per week for older than week but yonger one month.<br/>
34 |                            Files younger than one week, excluded.</p>
35 |                        <p><b>Older Than</b>: Delete files older than 'Period' and it number.</p>
36 |                        ]]></comment>
37 |                     </field>
38 |                     <field id="period" translate="label" type="select" sortOrder="20" showInDefault="1" showInStore="1" showInWebsite="1">
39 |                         <label>Period</label>
40 |                         <source_model>Overdose\CMSContent\Model\OptionSource\Periods</source_model>
41 |                         <depends>
42 |                             <field id="method">older_than</field>
43 |                         </depends>
44 |                     </field>
45 |                     <field id="number" translate="label" type="text" sortOrder="30" showInDefault="1" showInStore="1" showInWebsite="1">
46 |                         <label>Number</label>
47 |                         <depends>
48 |                             <field id="method">older_than</field>
49 |                         </depends>
50 |                     </field>
51 |                     <depends>
52 |                         <field id="cron_enabled">1</field>
53 |                     </depends>
54 |                 </group>
55 |                 <group id="cron_run_settings" translate="label" type="text" sortOrder="20" showInDefault="1" showInStore="1" showInWebsite="1">
56 |                     <label>Cron Run Settings</label>
57 |                     <field id="frequency" translate="label" type="select" sortOrder="10" showInDefault="1" showInStore="1" showInWebsite="1">
58 |                         <label>Frequency</label>
59 |                         <source_model>Magento\Cron\Model\Config\Source\Frequency</source_model>
60 |                         <backend_model>Overdose\CMSContent\Model\Config\Cron\SaveValue</backend_model>
61 |                     </field>
62 |                     <field id="time" translate="label" type="time" sortOrder="20" showInDefault="1" showInStore="1" showInWebsite="1">
63 |                         <label>Start Time</label>
64 |                         <comment><![CDATA[
65 |                         Hour : Minute : Second
66 |                        ]]></comment>
67 |                     </field>
68 |                     <depends>
69 |                         <field id="cron_enabled">1</field>
70 |                     </depends>
71 |                 </group>
72 |             </group>
73 | 
74 |             <group id="logs" translate="label" type="text" sortOrder="40" showInDefault="1" showInStore="1" showInWebsite="1">
75 |                 <label>Logs</label>
76 |                 <field id="logs_enabled" translate="label" type="select" sortOrder="10" showInDefault="1" showInStore="1" showInWebsite="1">
77 |                     <label>Enabled</label>
78 |                     <source_model>Magento\Config\Model\Config\Source\Yesno</source_model>
79 |                 </field>
80 |                 <depends>
81 |                     <field id="cron_enabled">1</field>
82 |                 </depends>
83 |             </group>
84 |         </section>
85 |     </system>
86 | </config>
87 | 


--------------------------------------------------------------------------------
/etc/cms_block_data.xsd:
--------------------------------------------------------------------------------
 1 | <xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
 2 |     <xs:element name="config">
 3 |         <xs:complexType>
 4 |             <xs:sequence>
 5 |                 <xs:element name="cms_blocks" maxOccurs="unbounded" minOccurs="0">
 6 |                     <xs:complexType>
 7 |                         <xs:sequence>
 8 |                             <xs:element name="cms_block" maxOccurs="unbounded" minOccurs="0">
 9 |                                 <xs:complexType>
10 |                                     <xs:sequence>
11 |                                         <xs:element name="attribute" maxOccurs="unbounded" minOccurs="0">
12 |                                             <xs:complexType>
13 |                                                 <xs:simpleContent>
14 |                                                     <xs:extension base="xs:string">
15 |                                                         <xs:attribute type="xs:string" name="code" use="required"/>
16 |                                                     </xs:extension>
17 |                                                 </xs:simpleContent>
18 |                                             </xs:complexType>
19 |                                         </xs:element>
20 |                                     </xs:sequence>
21 |                                     <xs:attribute type="xs:string" name="identifier"/>
22 |                                 </xs:complexType>
23 |                             </xs:element>
24 |                         </xs:sequence>
25 |                     </xs:complexType>
26 |                 </xs:element>
27 |             </xs:sequence>
28 |         </xs:complexType>
29 |     </xs:element>
30 | </xs:schema>


--------------------------------------------------------------------------------
/etc/cms_page_data.xsd:
--------------------------------------------------------------------------------
 1 | <xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
 2 |     <xs:element name="config">
 3 |         <xs:complexType>
 4 |             <xs:sequence>
 5 |                 <xs:element name="cms_pages" maxOccurs="unbounded" minOccurs="0">
 6 |                     <xs:complexType>
 7 |                         <xs:sequence>
 8 |                             <xs:element name="cms_page" maxOccurs="unbounded" minOccurs="0">
 9 |                                 <xs:complexType>
10 |                                     <xs:sequence>
11 |                                         <xs:element name="attribute" maxOccurs="unbounded" minOccurs="0">
12 |                                             <xs:complexType>
13 |                                                 <xs:simpleContent>
14 |                                                     <xs:extension base="xs:string">
15 |                                                         <xs:attribute type="xs:string" name="code" use="required"/>
16 |                                                     </xs:extension>
17 |                                                 </xs:simpleContent>
18 |                                             </xs:complexType>
19 |                                         </xs:element>
20 |                                     </xs:sequence>
21 |                                     <xs:attribute type="xs:string" name="identifier"/>
22 |                                 </xs:complexType>
23 |                             </xs:element>
24 |                         </xs:sequence>
25 |                     </xs:complexType>
26 |                 </xs:element>
27 |             </xs:sequence>
28 |         </xs:complexType>
29 |     </xs:element>
30 | </xs:schema>


--------------------------------------------------------------------------------
/etc/config.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Store:etc/config.xsd">
 3 |     <default>
 4 |         <cms_content>
 5 |             <general>
 6 |                 <enabled>0</enabled>
 7 |             </general>
 8 |             <backups>
 9 |                 <delete>
10 |                     <cron_enabled>0</cron_enabled>
11 |                     <method>older_than</method>
12 |                     <number>5</number>
13 |                 </delete>
14 |             </backups>
15 |         </cms_content>
16 |     </default>
17 | </config>
18 | 


--------------------------------------------------------------------------------
/etc/crontab.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0"?>
2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Cron:etc/crontab.xsd">
3 |     <group id="default">
4 |         <job name="cms_content_delete_backups" instance="Overdose\CMSContent\Cron\DeleteBackups" method="execute">
5 |             <config_path>crontab/default/jobs/cms_content_delete_backups/schedule/cron_expr</config_path>
6 |         </job>
7 |     </group>
8 | </config>
9 | 


--------------------------------------------------------------------------------
/etc/db_schema.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <schema xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Setup/Declaration/Schema/etc/schema.xsd">
 3 |     <table comment="od_cmscontent_version Table" engine="innodb" name="od_cmscontent_version" resource="default">
 4 |         <column comment="Entity Id" identity="true" name="id" nullable="false" padding="6" unsigned="false" xsi:type="smallint"/>
 5 |         <column name="type" nullable="false" xsi:type="smallint"/>
 6 |         <column name="identifier" length="255" nullable="false" xsi:type="varchar"/>
 7 |         <column name="version" default="1.0.0" length="255" nullable="false" xsi:type="varchar"/>
 8 |         <column name="store_ids" default="0" length="255" nullable="false" xsi:type="varchar"/>
 9 |         <constraint referenceId="PRIMARY" xsi:type="primary">
10 |             <column name="id"/>
11 |         </constraint>
12 |     </table>
13 | </schema>
14 | 


--------------------------------------------------------------------------------
/etc/module.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
 3 |     <module name="Overdose_CMSContent">
 4 |         <sequence>
 5 |             <module name="Magento_Cms"/>
 6 |             <module name="Overdose_Core" />
 7 |         </sequence>
 8 |     </module>
 9 | </config>
10 | 


--------------------------------------------------------------------------------
/etc/od_cms/cms_block_data.xml.sample:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="cms_block_data.xsd">
 3 |     <cms_blocks>
 4 |         <cms_block identifier="some-identifier">
 5 |             <attribute code="title">Some block title</attribute>
 6 |             <attribute code="content"><![CDATA[<div>Content here </div>]]></attribute>
 7 |             <attribute code="version">1.0.0</attribute>
 8 |             <attribute code="is_active">1</attribute>
 9 |             <attribute code="store_ids"/>
10 |         </cms_block>
11 |         <cms_block identifier="some-identifier-2">
12 |             <attribute code="title">Some block title 2 </attribute>
13 |             <attribute code="content"><![CDATA[<div>Content here 2</div>]]></attribute>
14 |             <attribute code="version">1.0.1</attribute>
15 |             <attribute code="is_active">1</attribute>
16 |             <attribute code="store_ids">1,2,3</attribute>
17 |         </cms_block>
18 |     </cms_blocks>
19 | </config>
20 | 


--------------------------------------------------------------------------------
/etc/od_cms/cms_page_data.xml.sample:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="cms_page_data.xsd">
 3 |     <cms_pages>
 4 |         <cms_page identifier="some-identifier">
 5 |             <attribute code="title">Some title</attribute>
 6 |             <attribute code="content"><![CDATA[<div>Content here </div>]]></attribute>
 7 |             <attribute code="version">1.0.0</attribute>
 8 |             <attribute code="is_active">1</attribute>
 9 |             <attribute code="store_ids"/>
10 |         </cms_page>
11 |         <cms_page identifier="some-identifier-2">
12 |             <attribute code="title">Some title 2</attribute>
13 |             <attribute code="content_heading">Some content heading 2</attribute>
14 |             <attribute code="content"><![CDATA[<div>Content here 2</div>]]></attribute>
15 |             <attribute code="page_layout">2columns-left</attribute>
16 |             <attribute code="version">1.0.1</attribute>
17 |             <attribute code="is_active">1</attribute>
18 |             <attribute code="store_ids">1,2,3</attribute>
19 |         </cms_page>
20 |     </cms_pages>
21 | </config>
22 | 


--------------------------------------------------------------------------------
/etc/od_cms/cms_page_data_no-route.xml.sample:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="cms_page_data.xsd">
 3 |   <cms_pages>
 4 |     <cms_page identifier="no-route">
 5 |       <attribute code="identifier">no-route</attribute>
 6 |       <attribute code="title">404 Not Found</attribute>
 7 |       <attribute code="page_layout">2columns-right</attribute>
 8 |       <attribute code="meta_keywords">Page keywords</attribute>
 9 |       <attribute code="meta_description">Page description</attribute>
10 |       <attribute code="content_heading">Whoops, our bad...</attribute>
11 |       <attribute code="content"><![CDATA[<dl>
12 | <dt>The page you requested was not found, and we have a fine guess why.</dt>
13 | <dd>
14 | <ul class="disc">
15 | <li>If you typed the URL directly, please make sure the spelling is correct.</li>
16 | <li>If you clicked on a link to get here, the link is outdated.</li>
17 | </ul></dd>
18 | </dl>
19 | <dl>
20 | <dt>What can you do?</dt>
21 | <dd>Have no fear, help is near! There are many ways you can get back on track with Magento Store.</dd>
22 | <dd>
23 | <ul class="disc">
24 | <li><a href="#" onclick="history.go(-1); return false;">Go back</a> to the previous page.</li>
25 | <li>Use the search bar at the top of the page to search for your products.</li>
26 | <li>Follow these links to get you back on track!<br /><a href="{{store url=""}}">Store Home</a> <span class="separator">|</span> <a href="{{store url="customer/account"}}">My Account</a></li></ul></dd></dl>
27 | ]]></attribute>
28 |       <attribute code="sort_order">0</attribute>
29 |       <attribute code="layout_update_xml"></attribute>
30 |       <attribute code="custom_theme"></attribute>
31 |       <attribute code="custom_root_template"></attribute>
32 |       <attribute code="custom_layout_update_xml"></attribute>
33 |       <attribute code="custom_theme_from"></attribute>
34 |       <attribute code="custom_theme_to"></attribute>
35 |       <attribute code="is_active">1</attribute>
36 |       <attribute code="store_ids">0</attribute>
37 |       <attribute code="version">1.0.1</attribute>
38 |     </cms_page>
39 |   </cms_pages>
40 | </config>
41 | 


--------------------------------------------------------------------------------
/registration.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | use Magento\Framework\Component\ComponentRegistrar;
6 | 
7 | ComponentRegistrar::register(ComponentRegistrar::MODULE, 'Overdose_CMSContent', __DIR__);
8 | 


--------------------------------------------------------------------------------
/view/adminhtml/layout/cmscontent_history_view.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">
 3 |     <update handle="styles"/>
 4 |     <update handle="editor" />
 5 |     <body>
 6 |         <attribute name="id" value="backup-html-body"/>
 7 |         <attribute name="class" value="backup-preview-window"/>
 8 |         <referenceContainer name="menu.wrapper" remove="true"/>
 9 |         <referenceContainer name="notices.wrapper" remove="true"/>
10 |         <referenceContainer name="content">
11 |             <uiComponent name="overdose_cmscontent_historyview_form"/>
12 |         </referenceContainer>
13 |     </body>
14 | </page>
15 | 


--------------------------------------------------------------------------------
/view/adminhtml/layout/cmscontent_import_index.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0"?>
2 | <page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">
3 |     <body>
4 |         <referenceContainer name="content">
5 |             <uiComponent name="cmscontent_import_form"/>
6 |         </referenceContainer>
7 |     </body>
8 | </page>
9 | 


--------------------------------------------------------------------------------
/view/adminhtml/templates/cms/backup/history.phtml:
--------------------------------------------------------------------------------
 1 | <?php /** @var \Overdose\CMSContent\Block\Adminhtml\Cms\CmsAbstract $block */ ?>
 2 | <?php $backups = $block->getBackups(); ?>
 3 | <div class="admin__field-label">
 4 |     <label>
 5 |         <span><?= __('Backups History')?></span>
 6 |     </label>
 7 | </div>
 8 | <div class="admin__field-control">
 9 | <?php if (!count($backups)) : ?>
10 |     <div>
11 |         <span><?= __('No records found'); ?></span>
12 |     </div>
13 | <?php else: ?>
14 |     <?php foreach ($backups as $backup) : ?>
15 |     <div class="backup-item">
16 |         <a href="#" onclick="popWin('<?= $block->getBackupUrl($backup) ?>','backupHistory','width=930,height=760,resizable=yes,scrollbars=yes')">
17 |             <?= $backup['label']; ?>
18 |         </a>
19 |         <a href="#" class="apply_backup" data-url="<?= $block->getBackupApplyUrl($backup) ?>"><button class="action-default"><?=__('Apply')?></button></a>
20 |     </div>
21 |     <?php endforeach; ?>
22 | </div>
23 | <div class="restore-message-content" style="display: none">
24 |     <?=__('This Action will rewrite existing content of the page/block from backup.')?>
25 |     <?=__('Do you want to proceed?')?>
26 | </div>
27 | <script>
28 |     require([
29 |         'jquery',
30 |         'Magento_Ui/js/modal/confirm'
31 |     ], function ($, confirmation) {
32 |         'use strict';
33 | 
34 |         $('.apply_backup').on('click', function() {
35 |             let url = $(this).attr('data-url');
36 |             $('.restore-message-content').confirm({
37 |                 title: $.mage.__('Restore backup content?'),
38 |                 actions: {
39 |                     confirm: function(){
40 |                         window.location.assign(url);
41 |                     },
42 |                     cancel: function(){
43 |                         window.location.reload();
44 |                     }
45 |                 }
46 |             });
47 |         });
48 |     });
49 | </script>
50 | <?php endif; ?>
51 | 


--------------------------------------------------------------------------------
/view/adminhtml/templates/history/view.phtml:
--------------------------------------------------------------------------------
1 | <?php /** @var View $block */
2 | 
3 | use Overdose\CMSContent\Block\Adminhtml\History\View;
4 | 
5 | ?>
6 | <?= $block->getBackupContent(); ?>
7 | 


--------------------------------------------------------------------------------
/view/adminhtml/ui_component/cms_block_form.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <form xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Ui:etc/ui_configuration.xsd">
 3 |     <fieldset name="history">
 4 |         <settings>
 5 |             <label/>
 6 |         </settings>
 7 |         <htmlContent name="backups" sortOrder="10">
 8 |             <argument name="data" xsi:type="array">
 9 |                 <item name="config" xsi:type="array">
10 |                     <item name="additionalClasses" xsi:type="array">
11 |                         <item name="admin__field" xsi:type="boolean">true</item>
12 |                     </item>
13 |                 </item>
14 |             </argument>
15 |             <block class="Overdose\CMSContent\Block\Adminhtml\Cms\Block\Edit\History"
16 |                    name="overdose.cmscontent.block.history"
17 |                    template="Overdose_CMSContent::cms/backup/history.phtml" />
18 |         </htmlContent>
19 |     </fieldset>
20 | </form>
21 | 


--------------------------------------------------------------------------------
/view/adminhtml/ui_component/cms_block_listing.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <listing xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Ui:etc/ui_configuration.xsd">
 3 |     <listingToolbar name="listing_top">
 4 |         <massaction name="listing_massaction">
 5 |             <action name="export_json">
 6 |                 <argument name="data" xsi:type="array">
 7 |                     <item name="config" xsi:type="array">
 8 |                         <item name="type" xsi:type="string">json_export</item>
 9 |                         <item name="label" xsi:type="string" translate="true">Export to JSON file</item>
10 |                         <item name="url" xsi:type="url" path="cmscontent/block/massExport"/>
11 |                     </item>
12 |                 </argument>
13 |             </action>
14 |             <action name="export_json_split">
15 |                 <argument name="data" xsi:type="array">
16 |                     <item name="config" xsi:type="array">
17 |                         <item name="type" xsi:type="string">json_split_export</item>
18 |                         <item name="label" xsi:type="string" translate="true">Export to split JSON files</item>
19 |                         <item name="url" xsi:type="url" path="cmscontent/block/massExport/split/1"/>
20 |                     </item>
21 |                 </argument>
22 |             </action>
23 |             <action name="export_xml">
24 |                 <argument name="data" xsi:type="array">
25 |                     <item name="config" xsi:type="array">
26 |                         <item name="type" xsi:type="string">xml_export</item>
27 |                         <item name="label" xsi:type="string" translate="true">Export to XML file</item>
28 |                         <item name="url" xsi:type="url" path="cmscontent/block/massExport/type/xml"/>
29 |                     </item>
30 |                 </argument>
31 |             </action>
32 |             <action name="export_xml_split">
33 |                 <argument name="data" xsi:type="array">
34 |                     <item name="config" xsi:type="array">
35 |                         <item name="type" xsi:type="string">xml_split_export</item>
36 |                         <item name="label" xsi:type="string" translate="true">Export to split XML files</item>
37 |                         <item name="url" xsi:type="url" path="cmscontent/block/massExport/type/xml/split/1"/>
38 |                     </item>
39 |                 </argument>
40 |             </action>
41 |         </massaction>
42 |     </listingToolbar>
43 | </listing>
44 | 


--------------------------------------------------------------------------------
/view/adminhtml/ui_component/cms_page_form.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <form xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Ui:etc/ui_configuration.xsd">
 3 |     <fieldset sortOrder="200" name="history">
 4 |         <settings>
 5 |             <collapsible>true</collapsible>
 6 |             <label translate="true">History</label>
 7 |         </settings>
 8 |         <htmlContent name="backups" sortOrder="10">
 9 |             <argument name="data" xsi:type="array">
10 |                 <item name="config" xsi:type="array">
11 |                     <item name="additionalClasses" xsi:type="array">
12 |                         <item name="admin__field" xsi:type="boolean">true</item>
13 |                     </item>
14 |                 </item>
15 |             </argument>
16 |             <block class="Overdose\CMSContent\Block\Adminhtml\Cms\Page\Edit\History"
17 |                    name="overdose.cmscontent.page.history"
18 |                    template="Overdose_CMSContent::cms/backup/history.phtml" />
19 |         </htmlContent>
20 |     </fieldset>
21 | </form>
22 | 


--------------------------------------------------------------------------------
/view/adminhtml/ui_component/cms_page_listing.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <listing xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Ui:etc/ui_configuration.xsd">
 3 |     <listingToolbar name="listing_top">
 4 |         <massaction name="listing_massaction">
 5 |             <action name="export_json">
 6 |                 <argument name="data" xsi:type="array">
 7 |                     <item name="config" xsi:type="array">
 8 |                         <item name="type" xsi:type="string">export_json</item>
 9 |                         <item name="label" xsi:type="string" translate="true">Export JSON</item>
10 |                         <item name="url" xsi:type="url" path="cmscontent/page/massExport"/>
11 |                     </item>
12 |                 </argument>
13 |             </action>
14 |             <action name="export_json_split">
15 |                 <argument name="data" xsi:type="array">
16 |                     <item name="config" xsi:type="array">
17 |                         <item name="type" xsi:type="string">export_json_split</item>
18 |                         <item name="label" xsi:type="string" translate="true">Export as split JSON files</item>
19 |                         <item name="url" xsi:type="url" path="cmscontent/page/massExport/split/1"/>
20 |                     </item>
21 |                 </argument>
22 |             </action>
23 |             <action name="export_xml">
24 |                 <argument name="data" xsi:type="array">
25 |                     <item name="config" xsi:type="array">
26 |                         <item name="type" xsi:type="string">export_xml</item>
27 |                         <item name="label" xsi:type="string" translate="true">Export XML</item>
28 |                         <item name="url" xsi:type="url" path="cmscontent/page/massExport/type/xml"/>
29 |                     </item>
30 |                 </argument>
31 |             </action>
32 |             <action name="export_xml_split">
33 |                 <argument name="data" xsi:type="array">
34 |                     <item name="config" xsi:type="array">
35 |                         <item name="type" xsi:type="string">export_xml_split</item>
36 |                         <item name="label" xsi:type="string" translate="true">Export as split XML files</item>
37 |                         <item name="url" xsi:type="url" path="cmscontent/page/massExport/type/xml/split/1"/>
38 |                     </item>
39 |                 </argument>
40 |             </action>
41 |         </massaction>
42 |     </listingToolbar>
43 | </listing>
44 | 


--------------------------------------------------------------------------------
/view/adminhtml/ui_component/cmscontent_import_form.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <form xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Ui:etc/ui_configuration.xsd">
 3 |     <argument name="data" xsi:type="array">
 4 |         <item name="js_config" xsi:type="array">
 5 |             <item name="provider" xsi:type="string">cmscontent_import_form.cmscontent_import_form_data_source</item>
 6 |         </item>
 7 |         <item name="label" xsi:type="string" translate="true">CMS Content Import</item>
 8 |         <item name="template" xsi:type="string">templates/form/collapsible</item>
 9 |     </argument>
10 | 
11 |     <settings>
12 |         <namespace>cmscontent_import_form</namespace>
13 |         <dataScope>data</dataScope>
14 |         <deps>
15 |             <dep>cmscontent_import_form.cmscontent_import_form_data_source</dep>
16 |         </deps>
17 |         <buttons>
18 |             <button name="save" class="Overdose\CMSContent\Block\Adminhtml\Import\Button\Import"/>
19 |         </buttons>
20 |     </settings>
21 | 
22 |     <dataSource name="cmscontent_import_form_data_source">
23 |         <argument name="data" xsi:type="array">
24 |             <item name="js_config" xsi:type="array">
25 |                 <item name="component" xsi:type="string">Magento_Ui/js/form/provider</item>
26 |             </item>
27 |         </argument>
28 |         <settings>
29 |             <submitUrl path="*/*/import"/>
30 |         </settings>
31 |         <dataProvider class="Overdose\CMSContent\Ui\DataProvider\Import" name="cmscontent_import_form_data_source">
32 |             <settings>
33 |                 <requestFieldName>id</requestFieldName>
34 |                 <primaryFieldName>id</primaryFieldName>
35 |             </settings>
36 |         </dataProvider>
37 |     </dataSource>
38 | 
39 |     <fieldset name="general" sortOrder="10">
40 |         <settings>
41 |             <label translate="true">General</label>
42 |         </settings>
43 |         <field name="upload" formElement="fileUploader">
44 |             <settings>
45 |                 <label translate="true">Upload (.zip)</label>
46 |             </settings>
47 |             <formElements>
48 |                 <fileUploader>
49 |                     <settings>
50 |                         <required>true</required>
51 |                         <allowedExtensions>zip</allowedExtensions>
52 |                         <uploaderConfig>
53 |                             <param xsi:type="url" name="url" path="*/*/upload"/>
54 |                             <param xsi:type="boolean" name="disableImageLoad">true</param>
55 |                         </uploaderConfig>
56 |                     </settings>
57 |                 </fileUploader>
58 |             </formElements>
59 |         </field>
60 |         <field name="cms_import_mode" formElement="select" sortOrder="90">
61 |             <settings>
62 |                 <dataType>text</dataType>
63 |                 <label translate="true">CMS Import Mode</label>
64 |             </settings>
65 |             <formElements>
66 |                 <select>
67 |                     <settings>
68 |                         <options class="Overdose\CMSContent\Model\OptionSource\CmsMode"/>
69 |                     </settings>
70 |                 </select>
71 |             </formElements>
72 |         </field>
73 |         <field name="media_import_mode" formElement="select" sortOrder="90">
74 |             <settings>
75 |                 <dataType>text</dataType>
76 |                 <label translate="true">Media Import Mode</label>
77 |             </settings>
78 |             <formElements>
79 |                 <select>
80 |                     <settings>
81 |                         <options class="Overdose\CMSContent\Model\OptionSource\MediaMode"/>
82 |                     </settings>
83 |                 </select>
84 |             </formElements>
85 |         </field>
86 |     </fieldset>
87 | </form>
88 | 


--------------------------------------------------------------------------------
/view/adminhtml/ui_component/overdose_cmscontent_historyview_form.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" ?>
 2 | <form xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Ui:etc/ui_configuration.xsd">
 3 |     <argument name="data" xsi:type="array">
 4 |         <item name="js_config" xsi:type="array">
 5 |             <item name="provider" xsi:type="string">overdose_cmscontent_historyview_form.historyview_form_data_source</item>
 6 |         </item>
 7 |         <item name="label" translate="true" xsi:type="string">General Information</item>
 8 |         <item name="template" xsi:type="string">templates/form/collapsible</item>
 9 |     </argument>
10 |     <settings>
11 |         <namespace>overdose_cmscontent_historyview_form</namespace>
12 |         <dataScope>data</dataScope>
13 |         <deps>
14 |             <dep>overdose_cmscontent_historyview_form.historyview_form_data_source</dep>
15 |         </deps>
16 |     </settings>
17 |     <dataSource name="historyview_form_data_source">
18 |         <argument name="data" xsi:type="array">
19 |             <item name="js_config" xsi:type="array">
20 |                 <item name="component" xsi:type="string">Magento_Ui/js/form/provider</item>
21 |             </item>
22 |         </argument>
23 |         <settings>
24 |             <submitUrl path="*/*/save"/>
25 |         </settings>
26 |         <dataProvider class="Overdose\CMSContent\Ui\DataProvider\HistoryView" name="historyview_form_data_source">
27 |             <settings>
28 |                 <requestFieldName>bc_identifier</requestFieldName>
29 |                 <primaryFieldName>bc_identifier</primaryFieldName>
30 |             </settings>
31 |         </dataProvider>
32 |     </dataSource>
33 |     <fieldset name="general">
34 |         <settings>
35 |             <label>General</label>
36 |         </settings>
37 |         <field name="identifier" formElement="input">
38 |             <argument name="data" xsi:type="array">
39 |                 <item name="config" xsi:type="array">
40 |                     <item name="label" xsi:type="string" translate="true">Identifier</item>
41 |                     <item name="source" xsi:type="string">block</item>
42 |                 </item>
43 |             </argument>
44 |             <settings>
45 |                 <dataScope>identifier</dataScope>
46 |             </settings>
47 |         </field>
48 |         <field name="title" formElement="input">
49 |             <argument name="data" xsi:type="array">
50 |                 <item name="config" xsi:type="array">
51 |                     <item name="label" xsi:type="string" translate="true">Title</item>
52 |                     <item name="source" xsi:type="string">block</item>
53 |                 </item>
54 |             </argument>
55 |             <settings>
56 |                 <dataScope>title</dataScope>
57 |             </settings>
58 |         </field>
59 |         <field formElement="wysiwyg" name="content" sortOrder="10">
60 |             <argument name="data" xsi:type="array">
61 |                 <item name="config" xsi:type="array">
62 |                     <item name="source" xsi:type="string">block</item>
63 |                 </item>
64 |             </argument>
65 |             <settings>
66 |                 <additionalClasses>
67 |                     <class name="admin__field-wide">true</class>
68 |                 </additionalClasses>
69 |                 <validation>
70 |                     <rule name="required-entry" xsi:type="boolean">false</rule>
71 |                 </validation>
72 |                 <label/>
73 |                 <dataScope>content</dataScope>
74 |             </settings>
75 |             <formElements>
76 |                 <wysiwyg>
77 |                     <settings>
78 |                         <wysiwyg>true</wysiwyg>
79 |                     </settings>
80 |                 </wysiwyg>
81 |             </formElements>
82 |         </field>
83 |     </fieldset>
84 | </form>
85 | 


--------------------------------------------------------------------------------