init

wp-content/plugins/mailpoet/lib/AdminPages/Pages/Automation.php

@@ -0,0 +1,140 @@
+<?php declare(strict_types = 1);
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\AssetsController;
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\AutomaticEmails\AutomaticEmails;
+use MailPoet\Automation\Engine\Data\AutomationTemplate;
+use MailPoet\Automation\Engine\Data\AutomationTemplateCategory;
+use MailPoet\Automation\Engine\Registry;
+use MailPoet\Automation\Engine\Storage\AutomationStorage;
+use MailPoet\Entities\NewsletterEntity;
+use MailPoet\Newsletter\NewslettersRepository;
+use MailPoet\Segments\SegmentsSimpleListRepository;
+use MailPoet\Settings\UserFlagsController;
+use MailPoet\WP\Functions as WPFunctions;
+
+class Automation {
+  /** @var AssetsController */
+  private $assetsController;
+
+  private AutomaticEmails $automaticEmails;
+
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  /** @var AutomationStorage */
+  private $automationStorage;
+
+  /** @var Registry  */
+  private $registry;
+
+  private NewslettersRepository $newslettersRepository;
+
+  private SegmentsSimpleListRepository $segmentsListRepository;
+
+  private UserFlagsController $userFlagsController;
+
+  public function __construct(
+    AssetsController $assetsController,
+    AutomaticEmails $automaticEmails,
+    PageRenderer $pageRenderer,
+    WPFunctions $wp,
+    AutomationStorage $automationStorage,
+    Registry $registry,
+    NewslettersRepository $newslettersRepository,
+    SegmentsSimpleListRepository $segmentsListRepository,
+    UserFlagsController $userFlagsController
+  ) {
+    $this->assetsController = $assetsController;
+    $this->automaticEmails = $automaticEmails;
+    $this->pageRenderer = $pageRenderer;
+    $this->wp = $wp;
+    $this->automationStorage = $automationStorage;
+    $this->registry = $registry;
+    $this->newslettersRepository = $newslettersRepository;
+    $this->segmentsListRepository = $segmentsListRepository;
+    $this->userFlagsController = $userFlagsController;
+  }
+
+  public function render() {
+    global $wp_roles; // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
+
+    $this->assetsController->setupAutomationListingDependencies();
+    $this->pageRenderer->displayPage('automation.html', [
+      'locale_full' => $this->wp->getLocale(),
+      'api' => [
+        'root' => rtrim($this->wp->escUrlRaw($this->wp->restUrl()), '/'),
+        'nonce' => $this->wp->wpCreateNonce('wp_rest'),
+      ],
+      'automationCount' => $this->automationStorage->getAutomationCount(),
+      'legacyAutomationCount' => $this->newslettersRepository->countBy([
+        'type' => [NewsletterEntity::TYPE_WELCOME, NewsletterEntity::TYPE_AUTOMATIC],
+      ]),
+      'templates' => array_map(
+        function(AutomationTemplate $template): array {
+          return $template->toArray();
+        },
+        array_values($this->registry->getTemplates())
+      ),
+      'template_categories' => array_map(
+        function (AutomationTemplateCategory $category): array {
+          return [
+            'slug' => $category->getSlug(),
+            'name' => $category->getName(),
+          ];
+        },
+        array_values($this->registry->getTemplateCategories())
+      ),
+      'registry' => $this->buildRegistry(),
+      'context' => $this->buildContext(),
+      'segments' => $this->segmentsListRepository->getListWithSubscribedSubscribersCounts(),
+      'roles' => $wp_roles->get_names() + ['mailpoet_all' => __('In any WordPress role', 'mailpoet')],
+      'automatic_emails' => $this->automaticEmails->getAutomaticEmails(),
+      'legacy_automations_notice_dismissed' => (bool)$this->userFlagsController->get('legacy_automations_notice_dismissed'),
+    ]);
+  }
+
+  private function buildRegistry(): array {
+    $steps = [];
+    foreach ($this->registry->getSteps() as $key => $step) {
+      $steps[$key] = [
+        'key' => $step->getKey(),
+        'name' => $step->getName(),
+        'args_schema' => $step->getArgsSchema()->toArray(),
+      ];
+    }
+
+    $subjects = [];
+    foreach ($this->registry->getSubjects() as $key => $subject) {
+      $subjects[$key] = [
+        'key' => $subject->getKey(),
+        'name' => $subject->getName(),
+        'args_schema' => $subject->getArgsSchema()->toArray(),
+        'field_keys' => array_map(function ($field) {
+          return $field->getKey();
+        }, $subject->getFields()),
+      ];
+    }
+
+    return [
+      'steps' => $steps,
+      'subjects' => $subjects,
+    ];
+  }
+
+  private function buildContext(): array {
+    $data = [];
+    foreach ($this->registry->getContextFactories() as $key => $factory) {
+      $data[$key] = $factory();
+    }
+    return $data;
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/AutomationAnalytics.php

@@ -0,0 +1,117 @@
+<?php declare(strict_types = 1);
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\AssetsController;
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Automation\Engine\Mappers\AutomationMapper;
+use MailPoet\Automation\Engine\Registry;
+use MailPoet\Automation\Engine\Storage\AutomationStorage;
+use MailPoet\WP\Functions as WPFunctions;
+use MailPoet\WP\Notice as WPNotice;
+
+class AutomationAnalytics {
+
+  /** @var AssetsController */
+  private $assetsController;
+
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var AutomationStorage */
+  private $automationStorage;
+
+  /** @var AutomationMapper */
+  private $automationMapper;
+
+  /** @var Registry */
+  private $registry;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  public function __construct(
+    AssetsController $assetsController,
+    PageRenderer $pageRenderer,
+    AutomationStorage $automationStorage,
+    AutomationMapper $automationMapper,
+    Registry $registry,
+    WPFunctions $wp
+  ) {
+    $this->assetsController = $assetsController;
+    $this->pageRenderer = $pageRenderer;
+    $this->automationStorage = $automationStorage;
+    $this->automationMapper = $automationMapper;
+    $this->registry = $registry;
+    $this->wp = $wp;
+  }
+
+  public function render() {
+    $this->assetsController->setupAutomationAnalyticsDependencies();
+
+    $id = isset($_GET['id']) ? (int)$_GET['id'] : null;
+    $automation = $id ? $this->automationStorage->getAutomation($id) : null;
+    if (!$automation) {
+      $notice = new WPNotice(
+        WPNotice::TYPE_ERROR,
+        __('Automation not found.', 'mailpoet')
+      );
+      $notice->displayWPNotice();
+      $this->pageRenderer->displayPage('blank.html');
+      return;
+    }
+
+    $this->pageRenderer->displayPage('automation/analytics.html', [
+      'registry' => $this->buildRegistry(),
+      'context' => $this->buildContext(),
+      'automation' => $this->automationMapper->buildAutomation($automation),
+      'locale_full' => $this->wp->getLocale(),
+      'api' => [
+        'root' => rtrim($this->wp->escUrlRaw($this->wp->restUrl()), '/'),
+        'nonce' => $this->wp->wpCreateNonce('wp_rest'),
+      ],
+      'jsonapi' => [
+        'root' => rtrim($this->wp->escUrlRaw(admin_url('admin-ajax.php')), '/'),
+      ],
+    ]);
+  }
+
+  private function buildRegistry(): array {
+    $steps = [];
+    foreach ($this->registry->getSteps() as $key => $step) {
+      $steps[$key] = [
+        'key' => $step->getKey(),
+        'name' => $step->getName(),
+        'args_schema' => $step->getArgsSchema()->toArray(),
+      ];
+    }
+
+    $subjects = [];
+    foreach ($this->registry->getSubjects() as $key => $subject) {
+      $subjects[$key] = [
+        'key' => $subject->getKey(),
+        'name' => $subject->getName(),
+        'args_schema' => $subject->getArgsSchema()->toArray(),
+        'field_keys' => array_map(function ($field) {
+          return $field->getKey();
+        }, $subject->getFields()),
+      ];
+    }
+
+    return [
+      'steps' => $steps,
+      'subjects' => $subjects,
+    ];
+  }
+
+  private function buildContext(): array {
+    $data = [];
+    foreach ($this->registry->getContextFactories() as $key => $factory) {
+      $data[$key] = $factory();
+    }
+    return $data;
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/AutomationEditor.php

@@ -0,0 +1,167 @@
+<?php declare(strict_types = 1);
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\AssetsController;
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Automation\Engine\Control\SubjectTransformerHandler;
+use MailPoet\Automation\Engine\Data\Automation;
+use MailPoet\Automation\Engine\Data\Field;
+use MailPoet\Automation\Engine\Hooks;
+use MailPoet\Automation\Engine\Integration\Trigger;
+use MailPoet\Automation\Engine\Mappers\AutomationMapper;
+use MailPoet\Automation\Engine\Registry;
+use MailPoet\Automation\Engine\Storage\AutomationStorage;
+use MailPoet\WP\Functions as WPFunctions;
+use MailPoet\WP\Notice as WPNotice;
+
+class AutomationEditor {
+  /** @var AssetsController */
+  private $assetsController;
+
+  /** @var AutomationMapper */
+  private $automationMapper;
+
+  /** @var AutomationStorage */
+  private $automationStorage;
+
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var Registry */
+  private $registry;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  /** @var SubjectTransformerHandler */
+  private $subjectTransformerHandler;
+
+  public function __construct(
+    AssetsController $assetsController,
+    AutomationMapper $automationMapper,
+    AutomationStorage $automationStorage,
+    PageRenderer $pageRenderer,
+    Registry $registry,
+    WPFunctions $wp,
+    SubjectTransformerHandler $subjectTransformerHandler
+  ) {
+    $this->assetsController = $assetsController;
+    $this->automationMapper = $automationMapper;
+    $this->automationStorage = $automationStorage;
+    $this->pageRenderer = $pageRenderer;
+    $this->registry = $registry;
+    $this->wp = $wp;
+    $this->subjectTransformerHandler = $subjectTransformerHandler;
+  }
+
+  public function render() {
+    $this->assetsController->setupAutomationEditorDependencies();
+
+    $id = isset($_GET['id']) ? (int)$_GET['id'] : null;
+
+    $this->wp->doAction(Hooks::EDITOR_BEFORE_LOAD, (int)$id);
+
+    $automation = $id ? $this->automationStorage->getAutomation($id) : null;
+    if (!$automation) {
+      $notice = new WPNotice(
+        WPNotice::TYPE_ERROR,
+        __('Automation not found.', 'mailpoet')
+      );
+      $notice->displayWPNotice();
+      $this->pageRenderer->displayPage('blank.html');
+      return;
+    }
+
+    if ($automation->getStatus() === Automation::STATUS_TRASH) {
+      $this->wp->wpSafeRedirect($this->wp->adminUrl('admin.php?page=mailpoet-automation&status=trash&notice=had-been-deleted'));
+      exit();
+    }
+
+    $this->pageRenderer->displayPage('automation/editor.html', [
+      'registry' => $this->buildRegistry(),
+      'context' => $this->buildContext(),
+      'automation' => $this->automationMapper->buildAutomation($automation),
+      'locale_full' => $this->wp->getLocale(),
+      'api' => [
+        'root' => rtrim($this->wp->escUrlRaw($this->wp->restUrl()), '/'),
+        'nonce' => $this->wp->wpCreateNonce('wp_rest'),
+      ],
+      'jsonapi' => [
+        'root' => rtrim($this->wp->escUrlRaw(admin_url('admin-ajax.php')), '/'),
+      ],
+    ]);
+  }
+
+  private function buildRegistry(): array {
+    $steps = [];
+    foreach ($this->registry->getSteps() as $key => $step) {
+      $steps[$key] = [
+        'key' => $step->getKey(),
+        'name' => $step->getName(),
+        'subject_keys' => $step instanceof Trigger ? $this->subjectTransformerHandler->getSubjectKeysForTrigger($step) : $step->getSubjectKeys(),
+        'args_schema' => $step->getArgsSchema()->toArray(),
+      ];
+    }
+
+    $subjects = [];
+    foreach ($this->registry->getSubjects() as $key => $subject) {
+      $subjectFields = $subject->getFields();
+      usort($subjectFields, function (Field $a, Field $b) {
+        return $a->getName() <=> $b->getName();
+      });
+
+      $subjects[$key] = [
+        'key' => $subject->getKey(),
+        'name' => $subject->getName(),
+        'args_schema' => $subject->getArgsSchema()->toArray(),
+        'field_keys' => array_map(function ($field) {
+          return $field->getKey();
+        }, $subjectFields),
+      ];
+    }
+
+    $fields = [];
+    foreach ($this->registry->getFields() as $key => $field) {
+      $fields[$key] = [
+        'key' => $field->getKey(),
+        'type' => $field->getType(),
+        'name' => $field->getName(),
+        'args' => $field->getArgs(),
+      ];
+    }
+
+    $filters = [];
+    foreach ($this->registry->getFilters() as $fieldType => $filter) {
+      $conditions = [];
+      foreach ($filter->getConditions() as $key => $label) {
+        $conditions[] = [
+          'key' => $key,
+          'label' => $label,
+        ];
+      }
+      $filters[$fieldType] = [
+        'field_type' => $filter->getFieldType(),
+        'conditions' => $conditions,
+      ];
+    }
+
+    return [
+      'steps' => $steps,
+      'subjects' => $subjects,
+      'fields' => $fields,
+      'filters' => $filters,
+    ];
+  }
+
+  private function buildContext(): array {
+    $data = [];
+    foreach ($this->registry->getContextFactories() as $key => $factory) {
+      $data[$key] = $factory();
+    }
+    return $data;
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/AutomationTemplates.php

@@ -0,0 +1,134 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\AssetsController;
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Automation\Engine\Data\AutomationTemplate;
+use MailPoet\Automation\Engine\Data\AutomationTemplateCategory;
+use MailPoet\Automation\Engine\Registry;
+use MailPoet\WP\Functions as WPFunctions;
+
+class AutomationTemplates {
+  /** @var AssetsController */
+  private $assetsController;
+
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var Registry  */
+  private $registry;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  public function __construct(
+    AssetsController $assetsController,
+    PageRenderer $pageRenderer,
+    Registry $registry,
+    WPFunctions $wp
+  ) {
+    $this->assetsController = $assetsController;
+    $this->pageRenderer = $pageRenderer;
+    $this->registry = $registry;
+    $this->wp = $wp;
+  }
+
+  public function render() {
+    $this->assetsController->setupAutomationTemplatesDependencies();
+
+    $this->pageRenderer->displayPage(
+      'automation/templates.html',
+      [
+        'locale_full' => $this->wp->getLocale(),
+        'api' => [
+          'root' => rtrim($this->wp->escUrlRaw($this->wp->restUrl()), '/'),
+          'nonce' => $this->wp->wpCreateNonce('wp_rest'),
+        ],
+        'templates' => array_map(
+          function(AutomationTemplate $template): array {
+            return $template->toArray();
+          },
+          array_values($this->registry->getTemplates())
+        ),
+        'template_categories' => array_map(
+          function (AutomationTemplateCategory $category): array {
+            return [
+              'slug' => $category->getSlug(),
+              'name' => $category->getName(),
+            ];
+          },
+          array_values($this->registry->getTemplateCategories())
+        ),
+        'registry' => $this->buildRegistry(),
+        'context' => $this->buildContext(),
+      ]
+    );
+  }
+
+  private function buildRegistry(): array {
+    $steps = [];
+    foreach ($this->registry->getSteps() as $key => $step) {
+      $steps[$key] = [
+        'key' => $step->getKey(),
+        'name' => $step->getName(),
+        'args_schema' => $step->getArgsSchema()->toArray(),
+      ];
+    }
+
+    $subjects = [];
+    foreach ($this->registry->getSubjects() as $key => $subject) {
+      $subjects[$key] = [
+        'key' => $subject->getKey(),
+        'name' => $subject->getName(),
+        'args_schema' => $subject->getArgsSchema()->toArray(),
+        'field_keys' => array_map(function ($field) {
+          return $field->getKey();
+        }, $subject->getFields()),
+      ];
+    }
+
+    $fields = [];
+    foreach ($this->registry->getFields() as $key => $field) {
+      $fields[$key] = [
+        'key' => $field->getKey(),
+        'type' => $field->getType(),
+        'name' => $field->getName(),
+        'args' => $field->getArgs(),
+      ];
+    }
+
+    $filters = [];
+    foreach ($this->registry->getFilters() as $fieldType => $filter) {
+      $conditions = [];
+      foreach ($filter->getConditions() as $key => $label) {
+        $conditions[] = [
+          'key' => $key,
+          'label' => $label,
+        ];
+      }
+      $filters[$fieldType] = [
+        'field_type' => $filter->getFieldType(),
+        'conditions' => $conditions,
+      ];
+    }
+
+    return [
+      'steps' => $steps,
+      'subjects' => $subjects,
+      'fields' => $fields,
+      'filters' => $filters,
+    ];
+  }
+
+  private function buildContext(): array {
+    $data = [];
+    foreach ($this->registry->getContextFactories() as $key => $factory) {
+      $data[$key] = $factory();
+    }
+    return $data;
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/DynamicSegments.php

@@ -0,0 +1,265 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\AssetsController;
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\API\JSON\ResponseBuilders\CustomFieldsResponseBuilder;
+use MailPoet\Automation\Engine\Data\Automation;
+use MailPoet\Automation\Engine\Storage\AutomationStorage;
+use MailPoet\CustomFields\CustomFieldsRepository;
+use MailPoet\Entities\DynamicSegmentFilterData;
+use MailPoet\Entities\FormEntity;
+use MailPoet\Entities\SegmentEntity;
+use MailPoet\Form\FormsRepository;
+use MailPoet\Listing\PageLimit;
+use MailPoet\Newsletter\NewslettersRepository;
+use MailPoet\Segments\SegmentDependencyValidator;
+use MailPoet\Segments\SegmentsRepository;
+use MailPoet\WooCommerce\Helper as WooCommerceHelper;
+use MailPoet\WP\AutocompletePostListLoader as WPPostListLoader;
+use MailPoet\WP\Functions as WPFunctions;
+use MailPoetVendor\Doctrine\Common\Collections\Criteria;
+
+class DynamicSegments {
+  /** @var AssetsController */
+  private $assetsController;
+
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var PageLimit */
+  private $listingPageLimit;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  /** @var WooCommerceHelper */
+  private $woocommerceHelper;
+
+  /** @var WPPostListLoader */
+  private $wpPostListLoader;
+
+  /** @var SegmentDependencyValidator */
+  private $segmentDependencyValidator;
+
+  /** @var CustomFieldsRepository */
+  private $customFieldsRepository;
+
+  /** @var CustomFieldsResponseBuilder */
+  private $customFieldsResponseBuilder;
+
+  /** @var SegmentsRepository */
+  private $segmentsRepository;
+
+  /** @var NewslettersRepository */
+  private $newslettersRepository;
+
+  /** @var FormsRepository */
+  private $formsRepository;
+
+  /** @var AutomationStorage */
+  private $automationStorage;
+
+  public function __construct(
+    AssetsController $assetsController,
+    PageRenderer $pageRenderer,
+    PageLimit $listingPageLimit,
+    WPFunctions $wp,
+    WooCommerceHelper $woocommerceHelper,
+    WPPostListLoader $wpPostListLoader,
+    CustomFieldsRepository $customFieldsRepository,
+    CustomFieldsResponseBuilder $customFieldsResponseBuilder,
+    SegmentDependencyValidator $segmentDependencyValidator,
+    SegmentsRepository $segmentsRepository,
+    NewslettersRepository $newslettersRepository,
+    FormsRepository $formsRepository,
+    AutomationStorage $automationStorage
+  ) {
+    $this->assetsController = $assetsController;
+    $this->pageRenderer = $pageRenderer;
+    $this->listingPageLimit = $listingPageLimit;
+    $this->wp = $wp;
+    $this->woocommerceHelper = $woocommerceHelper;
+    $this->wpPostListLoader = $wpPostListLoader;
+    $this->segmentDependencyValidator = $segmentDependencyValidator;
+    $this->customFieldsRepository = $customFieldsRepository;
+    $this->customFieldsResponseBuilder = $customFieldsResponseBuilder;
+    $this->segmentsRepository = $segmentsRepository;
+    $this->newslettersRepository = $newslettersRepository;
+    $this->formsRepository = $formsRepository;
+    $this->automationStorage = $automationStorage;
+  }
+
+  /**
+   * @return void
+   */
+  public function render() {
+    $data = [];
+    $data['dynamic_segment_count'] = $this->segmentsRepository->countBy([
+      'deletedAt' => null,
+      'type' => SegmentEntity::TYPE_DYNAMIC,
+    ]);
+    $data['items_per_page'] = $this->listingPageLimit->getLimitPerPage('segments');
+
+    $customFields = $this->customFieldsRepository->findBy([], ['name' => 'asc']);
+    $data['custom_fields'] = $this->customFieldsResponseBuilder->buildBatch($customFields);
+
+    $wpRoles = $this->wp->getEditableRoles();
+    $data['wordpress_editable_roles_list'] = array_map(function($roleId, $role) {
+      return [
+        'role_id' => $roleId,
+        'role_name' => $role['name'],
+      ];
+    }, array_keys($wpRoles), $wpRoles);
+
+    $data['newsletters_list'] = $this->getNewslettersList();
+
+    $data['static_segments_list'] = [];
+    $criteria = new Criteria();
+    $criteria->where(Criteria::expr()->isNull('deletedAt'));
+    $criteria->andWhere(Criteria::expr()->neq('type', SegmentEntity::TYPE_DYNAMIC));
+    $criteria->orderBy(['name' => 'ASC']);
+    $segments = $this->segmentsRepository->matching($criteria);
+    foreach ($segments as $segment) {
+      $data['static_segments_list'][] = [
+        'id' => $segment->getId(),
+        'name' => $segment->getName(),
+        'type' => $segment->getType(),
+        'description' => $segment->getDescription(),
+      ];
+    }
+
+    $data['product_attributes'] = [];
+    if ($this->woocommerceHelper->isWooCommerceActive()) {
+      $productAttributes = $this->woocommerceHelper->wcGetAttributeTaxonomies();
+
+      foreach ($productAttributes as $attribute) {
+        $taxonomy = 'pa_' . $attribute->attribute_name;// phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
+        $attributeTerms = $this->wp->getTerms(
+          [
+            'taxonomy' => $taxonomy,
+            'hide_empty' => false,
+          ]
+        );
+
+        if (!isset($attributeTerms['errors'])) {
+          $data['product_attributes'][$taxonomy] = [ // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
+            'id' => $attribute->attribute_id, // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
+            'label' => $attribute->attribute_label, // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
+            'terms' => $attributeTerms,
+            'taxonomy' => $taxonomy,
+          ];
+        }
+      }
+
+      // Fetch local attributes used for product variations
+      $data['local_product_attributes'] = [];
+      $localAttributes = $this->getLocalAttributesUsedInProductVariations();
+      foreach ($localAttributes as $localAttribute => $values) {
+        $data['local_product_attributes'][$localAttribute] = [
+          'name' => $localAttribute,
+          'values' => $values,
+        ];
+      }
+    }
+
+    $data['product_categories'] = $this->wpPostListLoader->getWooCommerceCategories();
+    $data['product_tags'] = $this->wpPostListLoader->getWooCommerceTags();
+
+    $data['products'] = $this->wpPostListLoader->getProducts();
+    $data['membership_plans'] = $this->wpPostListLoader->getMembershipPlans();
+    $data['subscription_products'] = $this->wpPostListLoader->getSubscriptionProducts();
+    $wcCountries = $this->woocommerceHelper->isWooCommerceActive() ? $this->woocommerceHelper->getAllowedCountries() : [];
+    $data['woocommerce_countries'] = array_map(function ($code, $name) {
+      return [
+        'name' => $name,
+        'code' => $code,
+      ];
+    }, array_keys($wcCountries), $wcCountries);
+    $data['can_use_woocommerce_memberships'] = $this->segmentDependencyValidator->canUseDynamicFilterType(
+      DynamicSegmentFilterData::TYPE_WOOCOMMERCE_MEMBERSHIP
+    );
+    $data['can_use_woocommerce_subscriptions'] = $this->segmentDependencyValidator->canUseDynamicFilterType(
+      DynamicSegmentFilterData::TYPE_WOOCOMMERCE_SUBSCRIPTION
+    );
+    $wooCurrencySymbol = $this->woocommerceHelper->isWooCommerceActive() ? $this->woocommerceHelper->getWoocommerceCurrencySymbol() : '';
+    $data['woocommerce_currency_symbol'] = html_entity_decode($wooCurrencySymbol);
+    $data['signup_forms'] = array_map(function(FormEntity $form) {
+      return [
+        'id' => $form->getId(),
+        'name' => $form->getName(),
+      ];
+    }, $this->formsRepository->findAll());
+
+    $data['woocommerce_payment_methods'] = [];
+    $data['woocommerce_shipping_methods'] = [];
+
+    if ($this->woocommerceHelper->isWooCommerceActive()) {
+      $allGateways = $this->woocommerceHelper->getPaymentGateways()->payment_gateways();
+      $paymentMethods = [];
+      foreach ($allGateways as $gatewayId => $gateway) {
+        $paymentMethods[] = [
+          'id' => $gatewayId,
+          'name' => $gateway->get_method_title(),
+        ];
+      }
+      $data['woocommerce_payment_methods'] = $paymentMethods;
+
+      $data['woocommerce_shipping_methods'] = array_values($this->woocommerceHelper->getShippingMethodInstancesData());
+    }
+    $data['automations'] = array_map(function(Automation $automation) {
+      return [
+        'id' => (string)$automation->getId(),
+        'name' => $automation->getName(),
+      ];
+    }, $this->automationStorage->getAutomations());
+
+    $this->assetsController->setupDynamicSegmentsDependencies();
+    $this->pageRenderer->displayPage('segments/dynamic.html', $data);
+  }
+
+  private function getLocalAttributesUsedInProductVariations(): array {
+    $attributes = [];
+
+    if (!$this->woocommerceHelper->isWooCommerceActive()) {
+      return $attributes;
+    }
+    global $wpdb;
+
+    $results = $wpdb->get_results($wpdb->prepare("
+      SELECT DISTINCT pm.meta_key, pm.meta_value
+      FROM %i pm
+      INNER JOIN %i p ON pm.post_id = p.ID
+      WHERE pm.meta_key LIKE %s
+      AND p.post_type = 'product_variation'
+      GROUP BY pm.meta_key, pm.meta_value
+    ", $wpdb->postmeta, $wpdb->posts, 'attribute_%'), ARRAY_A);
+
+    foreach ($results as $result) {
+      $attribute = substr($result['meta_key'], 10);
+      if (!isset($attributes[$attribute])) {
+        $attributes[$attribute] = [];
+      }
+      $attributes[$attribute][] = $result['meta_value'];
+    }
+
+    return $attributes;
+  }
+
+  private function getNewslettersList(): array {
+    $result = [];
+    foreach ($this->newslettersRepository->getStandardNewsletterList() as $newsletter) {
+      $result[] = [
+        'id' => (string)$newsletter->getId(),
+        'subject' => $newsletter->getSubject(),
+        'name' => $newsletter->getCampaignNameOrSubject(),
+        'sent_at' => ($sentAt = $newsletter->getSentAt()) ? $sentAt->format('Y-m-d H:i:s') : null,
+      ];
+    }
+    return $result;
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/ExperimentalFeatures.php

@@ -0,0 +1,23 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+
+class ExperimentalFeatures {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  public function __construct(
+    PageRenderer $pageRenderer
+  ) {
+    $this->pageRenderer = $pageRenderer;
+  }
+
+  public function render() {
+    $this->pageRenderer->displayPage('experimental-features.html', []);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/FormEditor.php

@@ -0,0 +1,374 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\AssetsController;
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\API\JSON\ResponseBuilders\CustomFieldsResponseBuilder;
+use MailPoet\Config\Localizer;
+use MailPoet\CustomFields\CustomFieldsRepository;
+use MailPoet\Entities\FormEntity;
+use MailPoet\Entities\SegmentEntity;
+use MailPoet\Form\Block;
+use MailPoet\Form\FormsRepository;
+use MailPoet\Form\Renderer as FormRenderer;
+use MailPoet\Form\Templates\TemplateRepository;
+use MailPoet\Form\Templates\Templates\Template10BelowPages;
+use MailPoet\Form\Templates\Templates\Template10FixedBar;
+use MailPoet\Form\Templates\Templates\Template10Popup;
+use MailPoet\Form\Templates\Templates\Template10SlideIn;
+use MailPoet\Form\Templates\Templates\Template10Widget;
+use MailPoet\Form\Templates\Templates\Template11BelowPages;
+use MailPoet\Form\Templates\Templates\Template11FixedBar;
+use MailPoet\Form\Templates\Templates\Template11Popup;
+use MailPoet\Form\Templates\Templates\Template11SlideIn;
+use MailPoet\Form\Templates\Templates\Template11Widget;
+use MailPoet\Form\Templates\Templates\Template12BelowPages;
+use MailPoet\Form\Templates\Templates\Template12FixedBar;
+use MailPoet\Form\Templates\Templates\Template12Popup;
+use MailPoet\Form\Templates\Templates\Template12SlideIn;
+use MailPoet\Form\Templates\Templates\Template12Widget;
+use MailPoet\Form\Templates\Templates\Template13BelowPages;
+use MailPoet\Form\Templates\Templates\Template13FixedBar;
+use MailPoet\Form\Templates\Templates\Template13Popup;
+use MailPoet\Form\Templates\Templates\Template13SlideIn;
+use MailPoet\Form\Templates\Templates\Template13Widget;
+use MailPoet\Form\Templates\Templates\Template14BelowPages;
+use MailPoet\Form\Templates\Templates\Template14FixedBar;
+use MailPoet\Form\Templates\Templates\Template14Popup;
+use MailPoet\Form\Templates\Templates\Template14SlideIn;
+use MailPoet\Form\Templates\Templates\Template14Widget;
+use MailPoet\Form\Templates\Templates\Template17BelowPages;
+use MailPoet\Form\Templates\Templates\Template17FixedBar;
+use MailPoet\Form\Templates\Templates\Template17Popup;
+use MailPoet\Form\Templates\Templates\Template17SlideIn;
+use MailPoet\Form\Templates\Templates\Template17Widget;
+use MailPoet\Form\Templates\Templates\Template18BelowPages;
+use MailPoet\Form\Templates\Templates\Template18FixedBar;
+use MailPoet\Form\Templates\Templates\Template18Popup;
+use MailPoet\Form\Templates\Templates\Template18SlideIn;
+use MailPoet\Form\Templates\Templates\Template18Widget;
+use MailPoet\Form\Templates\Templates\Template1BelowPages;
+use MailPoet\Form\Templates\Templates\Template1FixedBar;
+use MailPoet\Form\Templates\Templates\Template1Popup;
+use MailPoet\Form\Templates\Templates\Template1SlideIn;
+use MailPoet\Form\Templates\Templates\Template1Widget;
+use MailPoet\Form\Templates\Templates\Template3BelowPages;
+use MailPoet\Form\Templates\Templates\Template3FixedBar;
+use MailPoet\Form\Templates\Templates\Template3Popup;
+use MailPoet\Form\Templates\Templates\Template3SlideIn;
+use MailPoet\Form\Templates\Templates\Template3Widget;
+use MailPoet\Form\Templates\Templates\Template4BelowPages;
+use MailPoet\Form\Templates\Templates\Template4FixedBar;
+use MailPoet\Form\Templates\Templates\Template4Popup;
+use MailPoet\Form\Templates\Templates\Template4SlideIn;
+use MailPoet\Form\Templates\Templates\Template4Widget;
+use MailPoet\Form\Templates\Templates\Template6BelowPages;
+use MailPoet\Form\Templates\Templates\Template6FixedBar;
+use MailPoet\Form\Templates\Templates\Template6Popup;
+use MailPoet\Form\Templates\Templates\Template6SlideIn;
+use MailPoet\Form\Templates\Templates\Template6Widget;
+use MailPoet\Form\Templates\Templates\Template7BelowPages;
+use MailPoet\Form\Templates\Templates\Template7FixedBar;
+use MailPoet\Form\Templates\Templates\Template7Popup;
+use MailPoet\Form\Templates\Templates\Template7SlideIn;
+use MailPoet\Form\Templates\Templates\Template7Widget;
+use MailPoet\Form\Util\CustomFonts;
+use MailPoet\Form\Util\Export;
+use MailPoet\NotFoundException;
+use MailPoet\Router\Endpoints\FormPreview;
+use MailPoet\Router\Router;
+use MailPoet\Segments\SegmentsSimpleListRepository;
+use MailPoet\Settings\Pages;
+use MailPoet\Settings\UserFlagsController;
+use MailPoet\WP\AutocompletePostListLoader as WPPostListLoader;
+use MailPoet\WP\Functions as WPFunctions;
+
+class FormEditor {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var CustomFieldsRepository */
+  private $customFieldsRepository;
+
+  /** @var CustomFieldsResponseBuilder */
+  private $customFieldsResponseBuilder;
+
+  /** @var FormRenderer */
+  private $formRenderer;
+
+  /** @var Block\Date */
+  private $dateBlock;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  /** @var Localizer */
+  private $localizer;
+
+  /** @var TemplateRepository */
+  private $templatesRepository;
+
+  /** @var UserFlagsController */
+  private $userFlags;
+
+  /** @var WPPostListLoader */
+  private $wpPostListLoader;
+
+  /** @var SegmentsSimpleListRepository */
+  private $segmentsListRepository;
+
+  /** @var FormsRepository */
+  private $formsRepository;
+
+  private $activeTemplates = [
+    FormEntity::DISPLAY_TYPE_POPUP => [
+      Template1Popup::ID,
+      Template3Popup::ID,
+      Template4Popup::ID,
+      Template6Popup::ID,
+      Template7Popup::ID,
+      Template10Popup::ID,
+      Template11Popup::ID,
+      Template12Popup::ID,
+      Template13Popup::ID,
+      Template14Popup::ID,
+      Template17Popup::ID,
+      Template18Popup::ID,
+    ],
+    FormEntity::DISPLAY_TYPE_SLIDE_IN => [
+      Template1SlideIn::ID,
+      Template3SlideIn::ID,
+      Template4SlideIn::ID,
+      Template6SlideIn::ID,
+      Template7SlideIn::ID,
+      Template10SlideIn::ID,
+      Template11SlideIn::ID,
+      Template12SlideIn::ID,
+      Template13SlideIn::ID,
+      Template14SlideIn::ID,
+      Template17SlideIn::ID,
+      Template18SlideIn::ID,
+    ],
+    FormEntity::DISPLAY_TYPE_FIXED_BAR => [
+      Template1FixedBar::ID,
+      Template3FixedBar::ID,
+      Template4FixedBar::ID,
+      Template6FixedBar::ID,
+      Template7FixedBar::ID,
+      Template10FixedBar::ID,
+      Template11FixedBar::ID,
+      Template12FixedBar::ID,
+      Template13FixedBar::ID,
+      Template14FixedBar::ID,
+      Template17FixedBar::ID,
+      Template18FixedBar::ID,
+    ],
+    FormEntity::DISPLAY_TYPE_BELOW_POST => [
+      Template1BelowPages::ID,
+      Template3BelowPages::ID,
+      Template4BelowPages::ID,
+      Template6BelowPages::ID,
+      Template7BelowPages::ID,
+      Template10BelowPages::ID,
+      Template11BelowPages::ID,
+      Template12BelowPages::ID,
+      Template13BelowPages::ID,
+      Template14BelowPages::ID,
+      Template17BelowPages::ID,
+      Template18BelowPages::ID,
+    ],
+    FormEntity::DISPLAY_TYPE_OTHERS => [
+      Template1Widget::ID,
+      Template3Widget::ID,
+      Template4Widget::ID,
+      Template6Widget::ID,
+      Template7Widget::ID,
+      Template10Widget::ID,
+      Template11Widget::ID,
+      Template12Widget::ID,
+      Template13Widget::ID,
+      Template14Widget::ID,
+      Template17Widget::ID,
+      Template18Widget::ID,
+    ],
+  ];
+
+  /** @var AssetsController */
+  private $assetsController;
+
+  public function __construct(
+    AssetsController $assetsController,
+    PageRenderer $pageRenderer,
+    CustomFieldsRepository $customFieldsRepository,
+    CustomFieldsResponseBuilder $customFieldsResponseBuilder,
+    FormRenderer $formRenderer,
+    Block\Date $dateBlock,
+    WPFunctions $wp,
+    Localizer $localizer,
+    UserFlagsController $userFlags,
+    WPPostListLoader $wpPostListLoader,
+    TemplateRepository $templateRepository,
+    FormsRepository $formsRepository,
+    SegmentsSimpleListRepository $segmentsListRepository
+  ) {
+    $this->assetsController = $assetsController;
+    $this->pageRenderer = $pageRenderer;
+    $this->customFieldsRepository = $customFieldsRepository;
+    $this->customFieldsResponseBuilder = $customFieldsResponseBuilder;
+    $this->formRenderer = $formRenderer;
+    $this->dateBlock = $dateBlock;
+    $this->wp = $wp;
+    $this->localizer = $localizer;
+    $this->templatesRepository = $templateRepository;
+    $this->userFlags = $userFlags;
+    $this->wpPostListLoader = $wpPostListLoader;
+    $this->segmentsListRepository = $segmentsListRepository;
+    $this->formsRepository = $formsRepository;
+  }
+
+  public function render() {
+    if (!isset($_GET['id']) && !isset($_GET['action']) && !isset($_GET['template_id'])) {
+      $this->renderTemplateSelection();
+      return;
+    }
+    if (isset($_GET['template_id'])) {
+      $template = $this->templatesRepository->getFormTemplate(sanitize_text_field(wp_unslash($_GET['template_id'])));
+      $form = $template->toFormEntity();
+    } else {
+      $form = $this->getFormData((int)$_GET['id']);
+    }
+    $customFields = $this->customFieldsRepository->findAll();
+    if (!$form instanceof FormEntity) {
+      throw new NotFoundException('Form does not exist');
+    }
+    $dateTypes = $this->dateBlock->getDateTypes();
+    $data = [
+      'form' => $form->toArray(),
+      'form_exports' => [
+          'php' => Export::get('php'),
+          'iframe' => Export::get('iframe'),
+          'shortcode' => Export::get('shortcode'),
+      ],
+      'segments' => $this->segmentsListRepository->getListWithSubscribedSubscribersCounts([SegmentEntity::TYPE_DEFAULT]),
+      'styles' => $this->formRenderer->getCustomStyles($form),
+      'date_types' => array_map(function ($label, $value) {
+        return [
+          'label' => $label,
+          'value' => $value,
+        ];
+      }, $dateTypes, array_keys($dateTypes)),
+      'date_formats' => $this->dateBlock->getDateFormats(),
+      'month_names' => $this->dateBlock->getMonthNames(),
+      'custom_fields' => $this->customFieldsResponseBuilder->buildBatch($customFields),
+      'editor_tutorial_seen' => $this->userFlags->get('form_editor_tutorial_seen'),
+      'preview_page_url' => $this->getPreviewPageUrl(),
+      'custom_fonts' => CustomFonts::FONTS,
+      'translations' => $this->getGutenbergScriptsTranslations(),
+      'posts' => $this->wpPostListLoader->getPosts(),
+      'pages' => $this->wpPostListLoader->getPages(),
+      'categories' => $this->wpPostListLoader->getCategories(),
+      'tags' => $this->wpPostListLoader->getTags(),
+      'products' => $this->wpPostListLoader->getProducts(),
+      'product_categories' => $this->wpPostListLoader->getWooCommerceCategories(),
+      'product_tags' => $this->wpPostListLoader->getWooCommerceTags(),
+      'is_administrator' => $this->wp->currentUserCan('administrator'),
+      'theme_support_widgets' => $this->wp->wpGetThemeSupport('widgets'),
+      'theme_support_fse' => $this->wp->wpGetTheme()->is_block_theme(),
+    ];
+    $this->wp->wpEnqueueMedia();
+    $this->assetsController->setupFormEditorDependencies();
+    $this->pageRenderer->displayPage('form/editor.html', $data);
+  }
+
+  public function renderTemplateSelection() {
+    $templatesData = [];
+    foreach ($this->activeTemplates as $formType => $templateIds) {
+      $templateForms = $this->templatesRepository->getFormTemplates($this->activeTemplates[$formType]);
+      $templatesData[$formType] = [];
+      foreach ($templateForms as $templateId => $form) {
+        $templatesData[$formType][] = [
+          'id' => $templateId,
+          'name' => $form->getName(),
+          'thumbnail' => $form->getThumbnailUrl(),
+        ];
+      }
+    }
+    $data = [
+      'templates' => $templatesData,
+    ];
+    $this->assetsController->setupFormEditorDependencies();
+    $this->pageRenderer->displayPage('form/template_selection.html', $data);
+  }
+
+  private function getPreviewPageUrl() {
+    $mailpoetPage = Pages::getMailPoetPage(Pages::PAGE_SUBSCRIPTIONS);
+    if (!$mailpoetPage) {
+      return null;
+    }
+    $url = $this->wp->getPermalink($mailpoetPage);
+    $params = [
+      Router::NAME,
+      'endpoint=' . FormPreview::ENDPOINT,
+      'action=' . FormPreview::ACTION_VIEW,
+    ];
+    $url .= (parse_url($url, PHP_URL_QUERY) ? '&' : '?') . join('&', $params);
+    return $url;
+  }
+
+  /**
+   * JS Translations are distributed and loaded per script. We can't use wp_set_script_translations
+   * because translation filename is determined based on script filename and path.
+   * This function loads JSON files with Gutenberg script's translations distributed within WordPress.
+   * Implemented based on load_script_textdomain function
+   * @see https://developer.wordpress.org/reference/functions/load_script_textdomain/
+   * @return string[]
+   */
+  private function getGutenbergScriptsTranslations() {
+    $locale = $this->localizer->locale();
+    if (!$locale) {
+      return [];
+    }
+    // List of scripts - relative path to translations directory (default: wp-content/languages)
+    $translationsToLoad = [
+      'wp-includes/js/dist/blocks.js',
+      'wp-includes/js/dist/components.js',
+      'wp-includes/js/dist/block-editor.js',
+      'wp-includes/js/dist/block-library.js',
+      'wp-includes/js/dist/editor.js',
+      'wp-includes/js/dist/media-utils.js',
+      'wp-includes/js/dist/format-library.js',
+      'wp-includes/js/dist/edit-post.js',
+    ];
+
+    $translations = [];
+    foreach ($translationsToLoad as $translation) {
+      $file = WP_LANG_DIR . '/' . $locale . '-' . md5($translation) . '.json';
+      if (!file_exists($file)) {
+        continue;
+      }
+      $translationsData = file_get_contents($file);
+      if ($translationsData) {
+        $translations[] = $translationsData;
+      }
+    }
+    return $translations;
+  }
+
+  private function getFormData(int $id): ?FormEntity {
+    $form = $this->formsRepository->findOneById($id);
+    if (!$form instanceof FormEntity) {
+      return null;
+    }
+    $form->setStyles($this->formRenderer->getCustomStyles($form));
+    // Use empty settings in case they are corrupted or missing
+    if (!is_array($form->getSettings())) {
+      $initialFormTemplate = $this->templatesRepository->getFormTemplate(TemplateRepository::INITIAL_FORM_TEMPLATE);
+      $form->setSettings($initialFormTemplate->getSettings());
+    }
+    return $form;
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/Forms.php

@@ -0,0 +1,70 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\API\JSON\ResponseBuilders\SegmentsResponseBuilder;
+use MailPoet\Listing\PageLimit;
+use MailPoet\Segments\SegmentsRepository;
+use MailPoet\Settings\UserFlagsController;
+use MailPoet\WP\Functions as WPFunctions;
+
+class Forms {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var PageLimit */
+  private $listingPageLimit;
+
+  /** @var UserFlagsController */
+  private $userFlags;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  /** @var SegmentsRepository */
+  private $segmentsRepository;
+
+  /** @var SegmentsResponseBuilder */
+  private $segmentsResponseBuilder;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    PageLimit $listingPageLimit,
+    UserFlagsController $userFlags,
+    SegmentsRepository $segmentsRepository,
+    SegmentsResponseBuilder $segmentsResponseBuilder,
+    WPFunctions $wp
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->listingPageLimit = $listingPageLimit;
+    $this->userFlags = $userFlags;
+    $this->wp = $wp;
+    $this->segmentsRepository = $segmentsRepository;
+    $this->segmentsResponseBuilder = $segmentsResponseBuilder;
+  }
+
+  public function render() {
+    $data = [];
+    $data['items_per_page'] = $this->listingPageLimit->getLimitPerPage('forms');
+    $data['segments'] = $this->segmentsResponseBuilder->buildForListing($this->segmentsRepository->findAll());
+
+    $data = $this->getNPSSurveyData($data);
+
+    $this->pageRenderer->displayPage('forms.html', $data);
+  }
+
+  public function getNPSSurveyData($data) {
+    $data['display_nps_survey'] = false;
+    if ($this->userFlags->get('display_new_form_editor_nps_survey')) {
+      $data['current_wp_user'] = $this->wp->wpGetCurrentUser()->to_array();
+      $data['current_wp_user_firstname'] = $this->wp->wpGetCurrentUser()->user_firstname;
+      $data['display_nps_survey'] = true;
+      $this->userFlags->set('display_new_form_editor_nps_survey', false);
+    }
+    return $data;
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/Help.php

@@ -0,0 +1,169 @@
+<?php declare(strict_types = 1);
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Cron\ActionScheduler\Actions\DaemonRun;
+use MailPoet\Cron\ActionScheduler\Actions\DaemonTrigger;
+use MailPoet\Cron\CronHelper;
+use MailPoet\Cron\Workers\SendingQueue\SendingQueue;
+use MailPoet\Entities\ScheduledTaskEntity;
+use MailPoet\Mailer\MailerLog;
+use MailPoet\Newsletter\Sending\ScheduledTasksRepository;
+use MailPoet\Newsletter\Sending\SendingQueuesRepository;
+use MailPoet\Newsletter\Url as NewsletterURL;
+use MailPoet\Router\Endpoints\CronDaemon;
+use MailPoet\Services\Bridge;
+use MailPoet\SystemReport\SystemReportCollector;
+use MailPoet\WP\DateTime;
+use MailPoet\WP\Functions as WPFunctions;
+
+class Help {
+  private PageRenderer $pageRenderer;
+  private CronHelper $cronHelper;
+  private SystemReportCollector $systemReportCollector;
+  private Bridge $bridge;
+  private ScheduledTasksRepository $scheduledTasksRepository;
+  private SendingQueuesRepository $sendingQueuesRepository;
+  private NewsletterURL $newsletterUrl;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    CronHelper $cronHelper,
+    SystemReportCollector $systemReportCollector,
+    Bridge $bridge,
+    ScheduledTasksRepository $scheduledTasksRepository,
+    SendingQueuesRepository $sendingQueuesRepository,
+    NewsletterURL $newsletterUrl
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->cronHelper = $cronHelper;
+    $this->systemReportCollector = $systemReportCollector;
+    $this->bridge = $bridge;
+    $this->scheduledTasksRepository = $scheduledTasksRepository;
+    $this->sendingQueuesRepository = $sendingQueuesRepository;
+    $this->newsletterUrl = $newsletterUrl;
+  }
+
+  public function render() {
+    /**
+     * Filter the system info.
+     *
+     * @param array<string, string> $systemInfoData The system info data array.
+     */
+    $systemInfoData = WPFunctions::get()->applyFilters('mailpoet_system_info_data', $this->systemReportCollector->getData(true));
+
+    try {
+      $cronPingUrl = $this->cronHelper->getCronUrl(CronDaemon::ACTION_PING);
+      $cronPingResponse = $this->systemReportCollector->getCronPingResponse();
+    } catch (\Exception $e) {
+      $cronPingResponse = __('Can‘t generate cron URL.', 'mailpoet') . ' (' . $e->getMessage() . ')';
+      $cronPingUrl = $cronPingResponse;
+    }
+
+    $mailerLog = MailerLog::getMailerLog();
+    $mailerLog['sent'] = MailerLog::sentSince();
+    $bridgePingResponse = $this->systemReportCollector->getBridgePingResponse();
+    $systemStatusData = [
+      'cron' => [
+        'url' => $cronPingUrl,
+        'isReachable' => $this->cronHelper->validatePingResponse($cronPingResponse),
+        'pingResponse' => $cronPingResponse,
+      ],
+      'mss' => [
+        'enabled' => $this->bridge->isMailpoetSendingServiceEnabled(),
+        'isReachable' => $this->bridge->validateBridgePingResponse($bridgePingResponse),
+      ],
+      'cronStatus' => $this->cronHelper->getDaemon(),
+      'queueStatus' => $mailerLog,
+    ];
+
+    $systemStatusData['cronStatus']['accessible'] = $this->cronHelper->isDaemonAccessible();
+    $systemStatusData['queueStatus']['tasksStatusCounts'] = $this->scheduledTasksRepository->getCountsPerStatus();
+
+    $scheduledTasks = $this->scheduledTasksRepository->getLatestTasks(SendingQueue::TASK_TYPE);
+    $systemStatusData['queueStatus']['latestTasks'] = array_map(fn($task) => $this->buildTaskData($task), $scheduledTasks);
+
+    $this->pageRenderer->displayPage(
+      'help.html',
+      [
+        'systemInfoData' => $systemInfoData,
+        'systemStatusData' => $systemStatusData,
+        'actionSchedulerData' => $this->getActionSchedulerData(),
+      ]
+    );
+  }
+
+  private function getActionSchedulerData(): ?array {
+    if (!class_exists(\ActionScheduler_Store::class)) {
+      return null;
+    }
+    $actionSchedulerData = [];
+    $actionSchedulerData['version'] = \ActionScheduler_Versions::instance()->latest_version();
+    $actionSchedulerData['storage'] = str_replace('ActionScheduler_', '', get_class(\ActionScheduler_Store::instance()));
+    $actionSchedulerData['latestTrigger'] = $this->getLatestActionSchedulerActionDate(DaemonTrigger::NAME);
+    $actionSchedulerData['latestCompletedTrigger'] = $this->getLatestActionSchedulerActionDate(DaemonTrigger::NAME, 'complete');
+    $actionSchedulerData['latestCompletedRun'] = $this->getLatestActionSchedulerActionDate(DaemonRun::NAME, 'complete');
+    return $actionSchedulerData;
+  }
+
+  private function getLatestActionSchedulerActionDate(string $hook, string $status = null): ?string {
+    $query = [
+      'per_page' => 1,
+      'order' => 'DESC',
+      'hook' => $hook,
+    ];
+    if ($status) {
+      $query['status'] = $status;
+    }
+    $store = \ActionScheduler_Store::instance();
+    $action = $store->query_actions($query);
+    if (!empty($action)) {
+      $dateObject = $store->get_date($action[0]);
+      return $dateObject->format('Y-m-d H:i:s');
+    }
+    return null;
+  }
+
+  public function buildTaskData(ScheduledTaskEntity $task): array {
+    $queue = $newsletter = $subscriber = null;
+    if ($task->getType() === SendingQueue::TASK_TYPE) {
+      $queue = $this->sendingQueuesRepository->findOneBy(['task' => $task]);
+      $newsletter = $queue ? $queue->getNewsletter() : null;
+      $subscribers = $task->getSubscribers();
+      // We only show subscriber's email for 1:1 emails (e.g. automations) and not bulk campaigns
+      if ($subscribers->count() === 1) {
+        $subscriber = $subscribers->first() ? $subscribers->first()->getSubscriber() : null;
+      }
+    }
+
+    return [
+      'id' => $task->getId(),
+      'type' => $task->getType(),
+      'priority' => $task->getPriority(),
+      'updatedAt' => $task->getUpdatedAt()->format(DateTime::DEFAULT_DATE_TIME_FORMAT),
+      'scheduledAt' => $task->getScheduledAt() ?
+        $task->getScheduledAt()->format(DateTime::DEFAULT_DATE_TIME_FORMAT)
+        : null,
+      'cancelledAt' => $task->getCancelledAt() ?
+        $task->getCancelledAt()->format(DateTime::DEFAULT_DATE_TIME_FORMAT)
+        : null,
+      'status' => $task->getStatus(),
+      'newsletter' => $queue && $newsletter ? [
+        'newsletterId' => $newsletter->getId(),
+        'queueId' => $queue->getId(),
+        'subject' => $queue->getNewsletterRenderedSubject() ?: $newsletter->getSubject(),
+        'previewUrl' => $this->newsletterUrl->getViewInBrowserUrl($newsletter, null, $queue),
+      ] : [
+        'newsletterId' => null,
+        'queueId' => null,
+        'subject' => null,
+        'previewUrl' => null,
+      ],
+      'subscriberEmail' => $subscriber ? $subscriber->getEmail() : null,
+    ];
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/Homepage.php

@@ -0,0 +1,46 @@
+<?php declare(strict_types = 1);
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\AssetsController;
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Homepage\HomepageDataController;
+use MailPoet\Settings\SettingsController;
+
+class Homepage {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var SettingsController */
+  private $settingsController;
+
+  /** @var HomepageDataController */
+  private $homepageDataController;
+
+  /** @var AssetsController */
+  private $assetsController;
+
+  public function __construct(
+    AssetsController $assetsController,
+    PageRenderer $pageRenderer,
+    SettingsController $settingsController,
+    HomepageDataController $homepageDataController
+  ) {
+    $this->assetsController = $assetsController;
+    $this->pageRenderer = $pageRenderer;
+    $this->settingsController = $settingsController;
+    $this->homepageDataController = $homepageDataController;
+  }
+
+  public function render() {
+    $data = [
+      'mta_log' => $this->settingsController->get('mta_log'),
+      'homepage' => $this->homepageDataController->getPageData(),
+    ];
+    $this->assetsController->setupHomepageDependencies();
+    $this->pageRenderer->displayPage('homepage.html', $data);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/Landingpage.php

@@ -0,0 +1,39 @@
+<?php declare(strict_types = 1);
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Config\Menu;
+use MailPoet\Settings\SettingsController;
+use MailPoet\WP\Functions as WPFunctions;
+
+class Landingpage {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  private SettingsController $settingsController;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    WPFunctions $wp,
+    SettingsController $settingsController
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->wp = $wp;
+    $this->settingsController = $settingsController;
+  }
+
+  public function render() {
+    $data = [
+      'welcome_wizard_url' => $this->wp->adminUrl('admin.php?page=' . Menu::WELCOME_WIZARD_PAGE_SLUG),
+      'welcome_wizard_current_step' => $this->settingsController->get('welcome_wizard_current_step', ''),
+    ];
+    $this->pageRenderer->displayPage('landingpage.html', $data);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/Logs.php

@@ -0,0 +1,57 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Logging\LogRepository;
+use MailPoetVendor\Carbon\Carbon;
+
+class Logs {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var LogRepository */
+  private $logRepository;
+
+  public function __construct(
+    LogRepository $logRepository,
+    PageRenderer $pageRenderer
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->logRepository = $logRepository;
+  }
+
+  public function render() {
+    $search = isset($_GET['search']) ? sanitize_text_field(wp_unslash($_GET['search'])) : null;
+    $from = isset($_GET['from']) ? sanitize_text_field(wp_unslash($_GET['from'])) : null;
+    $to = isset($_GET['to']) ? sanitize_text_field(wp_unslash($_GET['to'])) : null;
+    $offset = isset($_GET['offset']) ? sanitize_text_field(wp_unslash($_GET['offset'])) : null;
+    $limit = isset($_GET['limit']) ? sanitize_text_field(wp_unslash($_GET['limit'])) : null;
+    $dateFrom = (new Carbon())->subDays(7);
+    $defaultFrom = $dateFrom->format('Y-m-d');
+    if (isset($from)) {
+      $dateFrom = new Carbon($from);
+    }
+    $dateTo = null;
+    if (isset($to)) {
+      $dateTo = new Carbon($to);
+    }
+    $logs = $this->logRepository->getLogs($dateFrom, $dateTo, $search, $offset, $limit);
+    $data = [
+      'logs' => [],
+      'logs_default_from' => $defaultFrom,
+    ];
+    foreach ($logs as $log) {
+      $data['logs'][] = [
+        'id' => $log->getId(),
+        'name' => $log->getName(),
+        'message' => $log->getMessage(),
+        'created_at' => ($createdAt = $log->getCreatedAt()) ? $createdAt->format('Y-m-d H:i:s') : null,
+      ];
+    }
+    $this->pageRenderer->displayPage('logs.html', $data);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/NewsletterEditor.php

@@ -0,0 +1,189 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\AssetsController;
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Entities\SubscriberEntity;
+use MailPoet\Form\Util\CustomFonts;
+use MailPoet\Newsletter\Renderer\Blocks\Coupon;
+use MailPoet\Newsletter\Shortcodes\ShortcodesHelper;
+use MailPoet\NewsletterTemplates\BrandStyles;
+use MailPoet\Settings\SettingsController;
+use MailPoet\Settings\UserFlagsController;
+use MailPoet\Subscribers\ConfirmationEmailCustomizer;
+use MailPoet\Subscribers\SubscribersRepository;
+use MailPoet\WooCommerce\Helper as WooCommerceHelper;
+use MailPoet\WooCommerce\TransactionalEmailHooks;
+use MailPoet\WooCommerce\TransactionalEmails;
+use MailPoet\WooCommerce\TransactionalEmails\Template as WooTransactionalEmailTemplate;
+use MailPoet\WP\AutocompletePostListLoader as WPPostListLoader;
+use MailPoet\WP\Functions as WPFunctions;
+
+class NewsletterEditor {
+  private const DATE_FORMAT = 'Y-m-d H:i:s';
+
+  private PageRenderer $pageRenderer;
+  private SettingsController $settings;
+  private UserFlagsController $userFlags;
+  private WooCommerceHelper $woocommerceHelper;
+  private WPFunctions $wp;
+  private TransactionalEmails $wcTransactionalEmails;
+  private ShortcodesHelper $shortcodesHelper;
+  private SubscribersRepository $subscribersRepository;
+  private TransactionalEmailHooks $wooEmailHooks;
+  private WPPostListLoader $wpPostListLoader;
+  private CustomFonts $customFonts;
+  private AssetsController $assetsController;
+  private BrandStyles $brandStyles;
+  private WooTransactionalEmailTemplate $template;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    SettingsController $settings,
+    UserFlagsController $userFlags,
+    WooCommerceHelper $woocommerceHelper,
+    WPFunctions $wp,
+    TransactionalEmails $wcTransactionalEmails,
+    ShortcodesHelper $shortcodesHelper,
+    SubscribersRepository $subscribersRepository,
+    TransactionalEmailHooks $wooEmailHooks,
+    WPPostListLoader $wpPostListLoader,
+    CustomFonts $customFonts,
+    AssetsController $assetsController,
+    WooTransactionalEmailTemplate $template,
+    BrandStyles $brandStyles
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->settings = $settings;
+    $this->userFlags = $userFlags;
+    $this->woocommerceHelper = $woocommerceHelper;
+    $this->wp = $wp;
+    $this->wcTransactionalEmails = $wcTransactionalEmails;
+    $this->shortcodesHelper = $shortcodesHelper;
+    $this->subscribersRepository = $subscribersRepository;
+    $this->wooEmailHooks = $wooEmailHooks;
+    $this->wpPostListLoader = $wpPostListLoader;
+    $this->customFonts = $customFonts;
+    $this->assetsController = $assetsController;
+    $this->template = $template;
+    $this->brandStyles = $brandStyles;
+  }
+
+  public function render() {
+    $this->setupImageSize();
+    $this->assetsController->setupNewsletterEditorDependencies();
+    $newsletterId = (isset($_GET['id']) ? (int)$_GET['id'] : 0);
+    $woocommerceTemplateId = (int)$this->settings->get(TransactionalEmails::SETTING_EMAIL_ID, null);
+    if (
+      $woocommerceTemplateId
+      && $newsletterId === $woocommerceTemplateId
+      && !$this->woocommerceHelper->isWooCommerceActive()
+    ) {
+      $location = 'admin.php?page=mailpoet-settings&enable-customizer-notice#woocommerce';
+      if (headers_sent()) {
+        echo '<script>window.location = "' . esc_js($location) . '";</script>';
+      } else {
+        header('Location: ' . $location, true, 302);
+      }
+      exit;
+    }
+
+    $subscriber = $this->subscribersRepository->getCurrentWPUser();
+    $subscriberData = $subscriber ? $this->formatSubscriber($subscriber) : [];
+    $woocommerceData = [];
+    $originalTemplateBody = null;
+    if ($this->woocommerceHelper->isWooCommerceActive()) {
+      $wcEmailSettings = $this->wcTransactionalEmails->getWCEmailSettings();
+
+      // Activate hooks for Woo emails styles so that we always load styles set in Woo email customizer
+      if ($newsletterId === (int)$this->settings->get(TransactionalEmails::SETTING_EMAIL_ID)) {
+        $this->wooEmailHooks->overrideStylesForWooEmails();
+        $originalTemplateBody = $this->template->create($wcEmailSettings);
+      }
+      $discountTypes = $this->woocommerceHelper->wcGetCouponTypes();
+      $discountType = (string)current(array_keys($discountTypes));
+      $amountMax = strpos($discountType, 'percent') !== false ? 100 : null;
+      $woocommerceData = [
+        'email_headings' => $this->wcTransactionalEmails->getEmailHeadings(),
+        'customizer_enabled' => (bool)$this->settings->get('woocommerce.use_mailpoet_editor'),
+        'coupon' => [
+          'config' => [
+            'discount_types' => array_map(function($label, $value): array {
+              return ['label' => $label, 'value' => $value];
+            }, $discountTypes, array_keys($discountTypes)),
+            'code_placeholder' => Coupon::CODE_PLACEHOLDER,
+            'price_decimal_separator' => $this->woocommerceHelper->wcGetPriceDecimalSeparator(),
+          ],
+          'defaults' => [
+            'code' => Coupon::CODE_PLACEHOLDER,
+            'discountType' => $discountType,
+            'amountMax' => $amountMax,
+          ],
+        ],
+      ];
+      $woocommerceData = array_merge($wcEmailSettings, $woocommerceData);
+    }
+
+    $confirmationEmailTemplateId = (int)$this->settings->get(ConfirmationEmailCustomizer::SETTING_EMAIL_ID, null);
+
+    $data = [
+      'customFontsEnabled' => $this->customFonts->displayCustomFonts(),
+      'shortcodes' => $this->shortcodesHelper->getShortcodes(),
+      'settings' => $this->settings->getAll(),
+      'editor_tutorial_seen' => $this->userFlags->get('editor_tutorial_seen'),
+      'current_wp_user' => array_merge($subscriberData, $this->wp->wpGetCurrentUser()->to_array()),
+      'woocommerce' => $woocommerceData,
+      'is_wc_transactional_email' => $newsletterId === $woocommerceTemplateId,
+      'is_confirmation_email_template' => $newsletterId === $confirmationEmailTemplateId,
+      'is_confirmation_email_customizer_enabled' => (bool)$this->settings->get('signup_confirmation.use_mailpoet_editor', false),
+      'original_template_body' => $originalTemplateBody,
+      'product_categories' => $this->wpPostListLoader->getWooCommerceCategories(),
+      'products' => $this->wpPostListLoader->getProducts(),
+      'brand_styles' => [
+        'available' => $this->brandStyles->isAvailable(),
+      ],
+    ];
+    $this->wp->wpEnqueueMedia();
+    $this->wp->wpEnqueueStyle('editor', $this->wp->includesUrl('css/editor.css'));
+    $this->pageRenderer->displayPage('newsletter/editor.html', $data);
+  }
+
+  private function formatSubscriber(SubscriberEntity $subscriber): array {
+    return [
+      'id' => $subscriber->getId(),
+      'wp_user_id' => $subscriber->getWpUserId(),
+      'is_woocommerce_user' => (string)$subscriber->getIsWoocommerceUser(), // BC compatibility
+      'first_name' => $subscriber->getFirstName(),
+      'last_name' => $subscriber->getLastName(),
+      'email' => $subscriber->getEmail(),
+      'status' => $subscriber->getStatus(),
+      'subscribed_ip' => $subscriber->getSubscribedIp(),
+      'confirmed_ip' => $subscriber->getConfirmedIp(),
+      'confirmed_at' => ($confirmedAt = $subscriber->getConfirmedAt()) ? $confirmedAt->format(self::DATE_FORMAT) : null,
+      'last_subscribed_at' => ($lastSubscribedAt = $subscriber->getLastSubscribedAt()) ? $lastSubscribedAt->format(self::DATE_FORMAT) : null,
+      'created_at' => ($createdAt = $subscriber->getCreatedAt()) ? $createdAt->format(self::DATE_FORMAT) : null,
+      'updated_at' => $subscriber->getUpdatedAt()->format(self::DATE_FORMAT),
+      'deleted_at' => ($deletedAt = $subscriber->getDeletedAt()) ? $deletedAt->format(self::DATE_FORMAT) : null,
+      'unconfirmed_data' => $subscriber->getUnconfirmedData(),
+      'source' => $subscriber->getSource(),
+      'count_confirmation' => $subscriber->getConfirmationsCount(),
+      'unsubscribe_token' => $subscriber->getUnsubscribeToken(),
+      'link_token' => $subscriber->getLinkToken(),
+    ];
+  }
+
+  private function setupImageSize(): void {
+    $this->wp->addFilter(
+      'image_size_names_choose',
+      function ($sizes): array {
+        return array_merge($sizes, [
+          'mailpoet_newsletter_max' => __('MailPoet Newsletter', 'mailpoet'),
+        ]);
+      }
+    );
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/Newsletters.php

@@ -0,0 +1,189 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\AutomaticEmails\AutomaticEmails;
+use MailPoet\Config\Env;
+use MailPoet\Config\Menu;
+use MailPoet\EmailEditor\Engine\Dependency_Check;
+use MailPoet\EmailEditor\Integrations\MailPoet\DependencyNotice;
+use MailPoet\Entities\NewsletterEntity;
+use MailPoet\Entities\SegmentEntity;
+use MailPoet\Listing\PageLimit;
+use MailPoet\Newsletter\NewslettersRepository;
+use MailPoet\NewsletterTemplates\NewsletterTemplatesRepository;
+use MailPoet\Segments\SegmentsSimpleListRepository;
+use MailPoet\Segments\WooCommerce;
+use MailPoet\Services\AuthorizedEmailsController;
+use MailPoet\Services\AuthorizedSenderDomainController;
+use MailPoet\Services\Bridge;
+use MailPoet\Settings\SettingsController;
+use MailPoet\Settings\UserFlagsController;
+use MailPoet\Util\License\Features\CapabilitiesManager;
+use MailPoet\WooCommerce\TransactionalEmails;
+use MailPoet\WP\AutocompletePostListLoader as WPPostListLoader;
+use MailPoet\WP\DateTime;
+use MailPoet\WP\Functions as WPFunctions;
+
+class Newsletters {
+  private PageRenderer $pageRenderer;
+
+  private PageLimit $listingPageLimit;
+
+  private WPFunctions $wp;
+
+  private SettingsController $settings;
+
+  private NewsletterTemplatesRepository $newsletterTemplatesRepository;
+
+  private AutomaticEmails $automaticEmails;
+
+  private WPPostListLoader $wpPostListLoader;
+
+  private SegmentsSimpleListRepository $segmentsListRepository;
+
+  private NewslettersRepository $newslettersRepository;
+
+  private Bridge $bridge;
+
+  private AuthorizedSenderDomainController $senderDomainController;
+
+  private AuthorizedEmailsController $authorizedEmailsController;
+
+  private UserFlagsController $userFlagsController;
+
+  private WooCommerce $wooCommerceSegment;
+
+  private Dependency_Check $dependencyCheck;
+
+  private DependencyNotice $dependencyNotice;
+
+  private CapabilitiesManager $capabilitiesManager;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    PageLimit $listingPageLimit,
+    WPFunctions $wp,
+    SettingsController $settings,
+    NewsletterTemplatesRepository $newsletterTemplatesRepository,
+    WPPostListLoader $wpPostListLoader,
+    AutomaticEmails $automaticEmails,
+    SegmentsSimpleListRepository $segmentsListRepository,
+    NewslettersRepository $newslettersRepository,
+    Bridge $bridge,
+    AuthorizedSenderDomainController $senderDomainController,
+    AuthorizedEmailsController $authorizedEmailsController,
+    UserFlagsController $userFlagsController,
+    WooCommerce $wooCommerceSegment,
+    Dependency_Check $dependencyCheck,
+    DependencyNotice $dependencyNotice,
+    CapabilitiesManager $capabilitiesManager
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->listingPageLimit = $listingPageLimit;
+    $this->wp = $wp;
+    $this->settings = $settings;
+    $this->newsletterTemplatesRepository = $newsletterTemplatesRepository;
+    $this->automaticEmails = $automaticEmails;
+    $this->wpPostListLoader = $wpPostListLoader;
+    $this->segmentsListRepository = $segmentsListRepository;
+    $this->newslettersRepository = $newslettersRepository;
+    $this->bridge = $bridge;
+    $this->senderDomainController = $senderDomainController;
+    $this->authorizedEmailsController = $authorizedEmailsController;
+    $this->userFlagsController = $userFlagsController;
+    $this->wooCommerceSegment = $wooCommerceSegment;
+    $this->dependencyCheck = $dependencyCheck;
+    $this->dependencyNotice = $dependencyNotice;
+    $this->capabilitiesManager = $capabilitiesManager;
+  }
+
+  public function render() {
+    global $wp_roles; // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
+
+    $data = [];
+
+    $data['items_per_page'] = $this->listingPageLimit->getLimitPerPage('newsletters');
+    $includedSegmentTypes = $this->wooCommerceSegment->shouldShowWooCommerceSegment() ? [] : SegmentEntity::NON_WOO_RELATED_TYPES;
+    $segments = $this->segmentsListRepository->getListWithSubscribedSubscribersCounts($includedSegmentTypes);
+    $data['segments'] = $segments;
+    $data['settings'] = $this->settings->getAll();
+    $data['current_wp_user'] = $this->wp->wpGetCurrentUser()->to_array();
+    $data['current_wp_user_firstname'] = $this->wp->wpGetCurrentUser()->user_firstname;
+    $data['roles'] = $wp_roles->get_names(); // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
+    $data['roles']['mailpoet_all'] = __('In any WordPress role', 'mailpoet');
+
+    $dateTime = new DateTime();
+    $data['current_date'] = $dateTime->getCurrentDate(DateTime::DEFAULT_DATE_FORMAT);
+    $data['tomorrow_date'] = $dateTime->getCurrentDateTime()->modify("+1 day")
+      ->format(DateTime::DEFAULT_DATE_FORMAT);
+    $data['current_time'] = $dateTime->getCurrentTime();
+    $data['current_date_time'] = $dateTime->getCurrentDateTime()->format(DateTime::DEFAULT_DATE_TIME_FORMAT);
+    $data['schedule_time_of_day'] = $dateTime->getTimeInterval(
+      '00:00:00',
+      '+15 minutes',
+      96
+    );
+    $data['mailpoet_emails_page'] = $this->wp->adminUrl('admin.php?page=' . Menu::EMAILS_PAGE_SLUG);
+    $data['show_congratulate_after_first_newsletter'] = isset($data['settings']['show_congratulate_after_first_newsletter']) ? $data['settings']['show_congratulate_after_first_newsletter'] : 'false';
+
+    $data['is_mailpoet_update_available'] = array_key_exists(Env::$pluginPath, $this->wp->getPluginUpdates());
+    $data['newsletters_count'] = $this->newslettersRepository->countBy([]);
+
+    $data['automatic_emails'] = $this->automaticEmails->getAutomaticEmails();
+    $data['woocommerce_optin_on_checkout'] = $this->settings->get('woocommerce.optin_on_checkout.enabled', false);
+
+    $data['sent_newsletters_count'] = $this->newslettersRepository->countBy(['status' => NewsletterEntity::STATUS_SENT]);
+    $data['woocommerce_transactional_email_id'] = $this->settings->get(TransactionalEmails::SETTING_EMAIL_ID);
+    $detailedAnalyticsCapability = $this->capabilitiesManager->getCapability('detailedAnalytics');
+    $data['display_detailed_stats'] = isset($detailedAnalyticsCapability) && !$detailedAnalyticsCapability->isRestricted;
+    $data['newsletters_templates_recently_sent_count'] = $this->newsletterTemplatesRepository->getRecentlySentCount();
+
+    $data['product_categories'] = $this->wpPostListLoader->getWooCommerceCategories();
+
+    $data['products'] = $this->wpPostListLoader->getProducts();
+
+    $data['authorized_emails'] = [];
+    $data['verified_sender_domains'] = [];
+    $data['partially_verified_sender_domains'] = [];
+    $data['all_sender_domains'] = [];
+    $data['sender_restrictions'] = [];
+
+    if ($this->bridge->isMailpoetSendingServiceEnabled()) {
+      $data['authorized_emails'] = $this->authorizedEmailsController->getAuthorizedEmailAddresses();
+      $data['verified_sender_domains'] = $this->senderDomainController->getFullyVerifiedSenderDomains(true);
+      $data['partially_verified_sender_domains'] = $this->senderDomainController->getPartiallyVerifiedSenderDomains(true);
+      $data['all_sender_domains'] = $this->senderDomainController->getAllSenderDomains();
+      $data['sender_restrictions'] = [
+        'lowerLimit' => AuthorizedSenderDomainController::LOWER_LIMIT,
+        'isAuthorizedDomainRequiredForNewCampaigns' => $this->senderDomainController->isAuthorizedDomainRequiredForNewCampaigns(),
+        'campaignTypes' => NewsletterEntity::CAMPAIGN_TYPES,
+      ];
+    }
+
+    $data['corrupt_newsletters'] = $this->getCorruptNewsletterSubjects();
+
+    $data['legacy_automatic_emails_count'] = $this->newslettersRepository->countBy([
+      'type' => [NewsletterEntity::TYPE_WELCOME, NewsletterEntity::TYPE_AUTOMATIC],
+    ]);
+
+    $data['legacy_automatic_emails_notice_dismissed'] = (bool)$this->userFlagsController->get('legacy_automatic_emails_notice_dismissed');
+
+    $data['block_email_editor_enabled'] = $this->dependencyCheck->are_dependencies_met(); // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
+    $this->dependencyNotice->displayMessageIfNeeded();
+    $this->pageRenderer->displayPage('newsletters.html', $data);
+  }
+
+  private function getCorruptNewsletterSubjects(): array {
+    return array_map(function ($newsletter) {
+      return [
+        'id' => $newsletter->getId(),
+        'subject' => $newsletter->getSubject(),
+      ];
+    }, $this->newslettersRepository->getCorruptNewsletters());
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/Settings.php

@@ -0,0 +1,135 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\AssetsController;
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Captcha\CaptchaRenderer;
+use MailPoet\Config\Installer;
+use MailPoet\Config\ServicesChecker;
+use MailPoet\Segments\SegmentsSimpleListRepository;
+use MailPoet\Services\AuthorizedEmailsController;
+use MailPoet\Services\AuthorizedSenderDomainController;
+use MailPoet\Services\Bridge;
+use MailPoet\Settings\Hosts;
+use MailPoet\Settings\Pages;
+use MailPoet\Settings\SettingsController;
+use MailPoet\WP\Functions as WPFunctions;
+use MailPoet\WP\Notice as WPNotice;
+
+class Settings {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var SettingsController */
+  private $settings;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  /** @var ServicesChecker */
+  private $servicesChecker;
+
+  /** @var CaptchaRenderer */
+  private $captchaRenderer;
+
+  /** @var SegmentsSimpleListRepository */
+  private $segmentsListRepository;
+
+  /** @var Bridge */
+  private $bridge;
+
+  /** @var AuthorizedSenderDomainController */
+  private $senderDomainController;
+
+  /** @var AuthorizedEmailsController */
+  private $authorizedEmailsController;
+
+  /** @var AssetsController */
+  private $assetsController;
+
+  public function __construct(
+    AssetsController $assetsController,
+    PageRenderer $pageRenderer,
+    SettingsController $settings,
+    WPFunctions $wp,
+    ServicesChecker $servicesChecker,
+    CaptchaRenderer $captchaRenderer,
+    SegmentsSimpleListRepository $segmentsListRepository,
+    Bridge $bridge,
+    AuthorizedSenderDomainController $senderDomainController,
+    AuthorizedEmailsController $authorizedEmailsController
+  ) {
+    $this->assetsController = $assetsController;
+    $this->pageRenderer = $pageRenderer;
+    $this->settings = $settings;
+    $this->wp = $wp;
+    $this->servicesChecker = $servicesChecker;
+    $this->captchaRenderer = $captchaRenderer;
+    $this->segmentsListRepository = $segmentsListRepository;
+    $this->bridge = $bridge;
+    $this->senderDomainController = $senderDomainController;
+    $this->authorizedEmailsController = $authorizedEmailsController;
+  }
+
+  public function render() {
+    $settings = $this->settings->getAll();
+
+    $premiumKeyValid = $this->servicesChecker->isPremiumKeyValid(false);
+    // force MSS key check even if the method isn't active
+    $mpApiKeyValid = $this->servicesChecker->isMailPoetAPIKeyValid(false, true);
+
+    $data = [
+      'settings' => $settings,
+      'segments' => $this->segmentsListRepository->getListWithSubscribedSubscribersCounts(),
+      'premium_key_valid' => !empty($premiumKeyValid),
+      'mss_key_valid' => !empty($mpApiKeyValid),
+      'pages' => Pages::getAll(),
+      'current_user' => $this->wp->wpGetCurrentUser(),
+      'is_members_plugin_active' => $this->wp->isPluginActive('members/members.php'),
+      'hosts' => [
+        'web' => Hosts::getWebHosts(),
+        'smtp' => Hosts::getSMTPHosts(),
+      ],
+      'paths' => [
+        'root' => ABSPATH,
+        'plugin' => dirname(dirname(dirname(__DIR__))),
+      ],
+      'current_site_title' => $this->wp->getBloginfo('name'),
+      'built_in_captcha_supported' => $this->captchaRenderer->isSupported(),
+    ];
+
+    $data['authorized_emails'] = [];
+    $data['verified_sender_domains'] = [];
+    $data['partially_verified_sender_domains'] = [];
+    $data['all_sender_domains'] = [];
+    $data['sender_restrictions'] = [];
+
+    if ($this->bridge->isMailpoetSendingServiceEnabled()) {
+      $data['authorized_emails'] = $this->authorizedEmailsController->getAuthorizedEmailAddresses();
+      $data['verified_sender_domains'] = $this->senderDomainController->getFullyVerifiedSenderDomains(true);
+      $data['partially_verified_sender_domains'] = $this->senderDomainController->getPartiallyVerifiedSenderDomains(true);
+      $data['all_sender_domains'] = $this->senderDomainController->getAllSenderDomains();
+      $data['sender_restrictions'] = [
+        'lowerLimit' => AuthorizedSenderDomainController::LOWER_LIMIT,
+      ];
+    }
+
+    $data = array_merge($data, Installer::getPremiumStatus());
+
+    if (isset($_GET['enable-customizer-notice'])) {
+      $notice = new WPNotice(WPNotice::TYPE_ERROR, _x(
+        'You need to have WooCommerce active to access the MailPoet email customizer for WooCommerce.',
+        'Notice in Settings when WooCommerce is not enabled',
+        'mailpoet'
+      ));
+      $notice->displayWPNotice();
+    }
+
+    $this->assetsController->setupSettingsDependencies();
+    $this->pageRenderer->displayPage('settings.html', $data);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/StaticSegments.php

@@ -0,0 +1,35 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Listing\PageLimit;
+
+class StaticSegments {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var PageLimit */
+  private $listingPageLimit;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    PageLimit $listingPageLimit
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->listingPageLimit = $listingPageLimit;
+  }
+
+  /**
+   * @return void
+   */
+  public function render() {
+    $data = [];
+    $data['items_per_page'] = $this->listingPageLimit->getLimitPerPage('segments');
+
+    $this->pageRenderer->displayPage('segments/static.html', $data);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/Subscribers.php

@@ -0,0 +1,75 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\API\JSON\ResponseBuilders\CustomFieldsResponseBuilder;
+use MailPoet\CustomFields\CustomFieldsRepository;
+use MailPoet\Entities\CustomFieldEntity;
+use MailPoet\Form\Block;
+use MailPoet\Listing\PageLimit;
+use MailPoet\Segments\SegmentsSimpleListRepository;
+
+class Subscribers {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var PageLimit */
+  private $listingPageLimit;
+
+  /** @var Block\Date */
+  private $dateBlock;
+
+  /** @var SegmentsSimpleListRepository */
+  private $segmentsListRepository;
+
+  /** @var CustomFieldsRepository */
+  private $customFieldsRepository;
+
+  /** @var CustomFieldsResponseBuilder */
+  private $customFieldsResponseBuilder;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    PageLimit $listingPageLimit,
+    Block\Date $dateBlock,
+    SegmentsSimpleListRepository $segmentsListRepository,
+    CustomFieldsRepository $customFieldsRepository,
+    CustomFieldsResponseBuilder $customFieldsResponseBuilder
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->listingPageLimit = $listingPageLimit;
+    $this->dateBlock = $dateBlock;
+    $this->segmentsListRepository = $segmentsListRepository;
+    $this->customFieldsRepository = $customFieldsRepository;
+    $this->customFieldsResponseBuilder = $customFieldsResponseBuilder;
+  }
+
+  public function render() {
+    $data = [];
+
+    $data['items_per_page'] = $this->listingPageLimit->getLimitPerPage('subscribers');
+    $data['segments'] = $this->segmentsListRepository->getListWithSubscribedSubscribersCounts();
+
+    $data['custom_fields'] = array_map(function(CustomFieldEntity $customField): array {
+      $field = $this->customFieldsResponseBuilder->build($customField);
+
+      if (!empty($field['params']['values'])) {
+        $values = [];
+
+        foreach ($field['params']['values'] as $value) {
+          $values[$value['value']] = $value['value'];
+        }
+        $field['params']['values'] = $values;
+      }
+      return $field;
+    }, $this->customFieldsRepository->findAll());
+
+    $data['date_formats'] = $this->dateBlock->getDateFormats();
+    $data['month_names'] = $this->dateBlock->getMonthNames();
+    $this->pageRenderer->displayPage('subscribers/subscribers.html', $data);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/SubscribersExport.php

@@ -0,0 +1,26 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Subscribers\ImportExport\ImportExportFactory;
+
+class SubscribersExport {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  public function __construct(
+    PageRenderer $pageRenderer
+  ) {
+    $this->pageRenderer = $pageRenderer;
+  }
+
+  public function render() {
+    $export = new ImportExportFactory(ImportExportFactory::EXPORT_ACTION);
+    $data = $export->bootstrap();
+    $this->pageRenderer->displayPage('subscribers/importExport/export.html', $data);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/SubscribersImport.php

@@ -0,0 +1,39 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Form\Block;
+use MailPoet\Services\Validator;
+use MailPoet\Subscribers\ImportExport\ImportExportFactory;
+
+class SubscribersImport {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var Block\Date */
+  private $dateBlock;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    Block\Date $dateBlock
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->dateBlock = $dateBlock;
+  }
+
+  public function render() {
+    $import = new ImportExportFactory(ImportExportFactory::IMPORT_ACTION);
+    $data = $import->bootstrap();
+    $data = array_merge($data, [
+      'date_types' => $this->dateBlock->getDateTypes(),
+      'date_formats' => $this->dateBlock->getDateFormats(),
+      'month_names' => $this->dateBlock->getMonthNames(),
+      'role_based_emails' => json_encode(Validator::ROLE_EMAILS),
+    ]);
+    $this->pageRenderer->displayPage('subscribers/importExport/import.html', $data);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/Upgrade.php

@@ -0,0 +1,48 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Util\License\Features\CapabilitiesManager;
+use MailPoet\WP\Functions as WPFunctions;
+
+class Upgrade {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  private CapabilitiesManager $capabilitiesManager;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    WPFunctions $wp,
+    CapabilitiesManager $capabilitiesManager
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->wp = $wp;
+    $this->capabilitiesManager = $capabilitiesManager;
+  }
+
+  public function render() {
+    $data = [
+      'current_wp_user' => $this->wp->wpGetCurrentUser()->to_array(),
+    ];
+
+    // @todo change this after a/b test to keep only one of the pages
+    if ($this->capabilitiesManager->showNewUpgradePage()) {
+      $data = [
+        'current_mailpoet_plan_tier' => $this->capabilitiesManager->getTier(),
+      ];
+
+      $this->pageRenderer->displayPage('upgrade_tiers.html', $data);
+      return;
+    }
+
+    $this->pageRenderer->displayPage('upgrade.html', $data);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/WelcomeWizard.php

@@ -0,0 +1,94 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Config\Menu;
+use MailPoet\Config\ServicesChecker;
+use MailPoet\Settings\SettingsController;
+use MailPoet\WooCommerce\Helper as WooCommerceHelper;
+use MailPoet\WP\Functions as WPFunctions;
+
+class WelcomeWizard {
+  const TRACK_LOADDED_VIA_WOOCOMMERCE_SETTING_NAME = 'send_event_that_wizard_was_loaded_via_woocommerce';
+  const TRACK_LOADDED_VIA_WOOCOMMERCE_MARKETING_DASHBOARD_SETTING_NAME = 'wizard_loaded_via_woocommerce_marketing_dashboard';
+
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var SettingsController */
+  private $settings;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  /** @var WooCommerceHelper */
+  private $wooCommerceHelper;
+
+  /** @var ServicesChecker */
+  private $servicesChecker;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    SettingsController $settings,
+    WooCommerceHelper $wooCommerceHelper,
+    WPFunctions $wp,
+    ServicesChecker $servicesChecker
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->settings = $settings;
+    $this->wooCommerceHelper = $wooCommerceHelper;
+    $this->wp = $wp;
+    $this->servicesChecker = $servicesChecker;
+  }
+
+  public function render() {
+    if ((bool)(defined('DOING_AJAX') && DOING_AJAX)) return;
+
+    $loadedViaWooCommerce = $this->settings->get(WelcomeWizard::TRACK_LOADDED_VIA_WOOCOMMERCE_SETTING_NAME, false);
+
+    if (!$loadedViaWooCommerce && isset($_GET['mailpoet_wizard_loaded_via_woocommerce'])) {
+      // This setting is used to send an event to Mixpanel in another request as, before completing the wizard, Mixpanel is not enabled.
+      $this->settings->set(WelcomeWizard::TRACK_LOADDED_VIA_WOOCOMMERCE_SETTING_NAME, 1);
+    }
+
+    $loadedViaWooCommerceMarketingDashboard = $this->settings->get(WelcomeWizard::TRACK_LOADDED_VIA_WOOCOMMERCE_MARKETING_DASHBOARD_SETTING_NAME, false);
+
+    if (!$loadedViaWooCommerceMarketingDashboard && isset($_GET['mailpoet_wizard_loaded_via_woocommerce_marketing_dashboard'])) {
+      // This setting is used to send an event to Mixpanel in another request as, before completing the wizard, Mixpanel is not enabled.
+      $this->settings->set(WelcomeWizard::TRACK_LOADDED_VIA_WOOCOMMERCE_MARKETING_DASHBOARD_SETTING_NAME, 1);
+    }
+
+
+    $premiumKeyValid = $this->servicesChecker->isPremiumKeyValid(false);
+    // force MSS key check even if the method isn't active
+    $mpApiKeyValid = $this->servicesChecker->isMailPoetAPIKeyValid(false, true);
+
+    $data = [
+      'finish_wizard_url' => $this->wp->adminUrl('admin.php?page=' . Menu::MAIN_PAGE_SLUG),
+      'admin_email' => $this->wp->getOption('admin_email'),
+      'current_wp_user' => $this->wp->wpGetCurrentUser()->to_array(),
+      'show_customers_import' => $this->wooCommerceHelper->getCustomersCount() > 0,
+      'settings' => $this->getSettings(),
+      'premium_key_valid' => !empty($premiumKeyValid),
+      'mss_key_valid' => !empty($mpApiKeyValid),
+      'has_tracking_settings' => $this->settings->hasSavedValue('analytics') && $this->settings->hasSavedValue('3rd_party_libs'),
+      'welcome_wizard_current_step' => $this->settings->get('welcome_wizard_current_step', ''),
+    ];
+    $this->pageRenderer->displayPage('welcome_wizard.html', $data);
+  }
+
+  private function getSettings(): array {
+    $settings = $this->settings->getAll();
+
+    $user = $this->wp->wpGetCurrentUser();
+    $settings['sender'] = [
+      'name' => $user->display_name, // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
+      'address' => $user->user_email, // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
+    ];
+    return $settings;
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/WooCommerceSetup.php

@@ -0,0 +1,41 @@
+<?php // phpcs:ignore SlevomatCodingStandard.TypeHints.DeclareStrictTypes.DeclareStrictTypesMissing
+
+namespace MailPoet\AdminPages\Pages;
+
+if (!defined('ABSPATH')) exit;
+
+
+use MailPoet\AdminPages\PageRenderer;
+use MailPoet\Config\Menu;
+use MailPoet\WooCommerce\Helper;
+use MailPoet\WP\Functions as WPFunctions;
+
+class WooCommerceSetup {
+  /** @var PageRenderer */
+  private $pageRenderer;
+
+  /** @var WPFunctions */
+  private $wp;
+
+  /** @var Helper */
+  private $wooCommerceHelper;
+
+  public function __construct(
+    PageRenderer $pageRenderer,
+    Helper $wooCommerceHelper,
+    WPFunctions $wp
+  ) {
+    $this->pageRenderer = $pageRenderer;
+    $this->wooCommerceHelper = $wooCommerceHelper;
+    $this->wp = $wp;
+  }
+
+  public function render() {
+    if ((bool)(defined('DOING_AJAX') && DOING_AJAX)) return;
+    $data = [
+      'finish_wizard_url' => $this->wp->adminUrl('admin.php?page=' . Menu::MAIN_PAGE_SLUG),
+      'show_customers_import' => $this->wooCommerceHelper->getCustomersCount() > 0,
+    ];
+    $this->pageRenderer->displayPage('woocommerce_setup.html', $data);
+  }
+}

wp-content/plugins/mailpoet/lib/AdminPages/Pages/index.php

@@ -0,0 +1 @@
+<?php