Added API/Endpoint abstract class

- (re)Added Endpoints folder to both API and Router
- fixed syntax in namespaces
- xhr.responseJSON is returned to the fail()
- fixed Router endpoints (view in browser, cron,...)

lib/API/Endpoints/AutomatedLatestContent.php

@@ -0,0 +1,64 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+if(!defined('ABSPATH')) exit;
+
+class AutomatedLatestContent {
+  public $ALC;
+
+  function __construct() {
+    $this->ALC = new \MailPoet\Newsletter\AutomatedLatestContent();
+  }
+
+  function getPostTypes() {
+    return get_post_types(array(), 'objects');
+  }
+
+  function getTaxonomies($args) {
+    $post_type = (isset($args['postType'])) ? $args['postType'] : 'post';
+    return get_object_taxonomies($post_type, 'objects');
+  }
+
+  function getTerms($args) {
+    $taxonomies = (isset($args['taxonomies'])) ? $args['taxonomies'] : array();
+    $search = (isset($args['search'])) ? $args['search'] : '';
+    $limit = (isset($args['limit'])) ? (int)$args['limit'] : 10;
+    $page = (isset($args['page'])) ? (int)$args['page'] : 1;
+    return get_terms(
+      $taxonomies,
+      array(
+        'hide_empty' => false,
+        'search' => $search,
+        'number' => $limit,
+        'offset' => $limit * ($page - 1)
+      )
+    );
+  }
+
+  function getPosts($args) {
+    return $this->ALC->getPosts($args);
+  }
+
+  function getTransformedPosts($args) {
+    $posts = $this->ALC->getPosts($args);
+    return $this->ALC->transformPosts($args, $posts);
+  }
+
+  function getBulkTransformedPosts($args) {
+    $alc = new \MailPoet\Newsletter\AutomatedLatestContent();
+
+    $used_posts = array();
+    $rendered_posts = array();
+
+    foreach($args['blocks'] as $block) {
+      $posts = $alc->getPosts($block, $used_posts);
+      $rendered_posts[] = $alc->transformPosts($block, $posts);
+
+      foreach($posts as $post) {
+        $used_posts[] = $post->ID;
+      }
+    }
+
+    return $rendered_posts;
+  }
+}

lib/API/Endpoints/Cron.php

@@ -0,0 +1,36 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+use MailPoet\Cron\CronHelper;
+use MailPoet\Cron\Supervisor;
+use MailPoet\Models\Setting;
+
+if(!defined('ABSPATH')) exit;
+
+class Cron {
+  function start() {
+    $supervisor = new Supervisor($force_run = true);
+    return $supervisor->checkDaemon();
+  }
+
+  function stop() {
+    $daemon = CronHelper::getDaemon();
+    if(!$daemon || $daemon['status'] !== 'started') {
+      $result = false;
+    } else {
+      $daemon['status'] = 'stopping';
+      $result = CronHelper::saveDaemon($daemon);
+    }
+    return array(
+      'result' => $result
+    );
+  }
+
+  function getStatus() {
+    $daemon = Setting::where('name', 'cron_daemon')
+      ->findOne();
+    return ($daemon) ?
+      unserialize($daemon->value) :
+      false;
+  }
+}

lib/API/Endpoints/CustomFields.php

@@ -0,0 +1,60 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+use \MailPoet\Models\CustomField;
+
+if(!defined('ABSPATH')) exit;
+
+class CustomFields {
+  function __construct() {
+  }
+
+  function getAll() {
+    $collection = CustomField::findMany();
+    $custom_fields = array_map(function($custom_field) {
+      return $custom_field->asArray();
+    }, $collection);
+
+    return $custom_fields;
+  }
+
+  function delete($id) {
+    $custom_field = CustomField::findOne($id);
+    if($custom_field === false or !$custom_field->id()) {
+      return array('result' => false);
+    } else {
+      $custom_field->delete();
+
+      return array(
+        'result' => true,
+        'field' => $custom_field->asArray()
+      );
+    }
+  }
+
+  function save($data = array()) {
+    $custom_field = CustomField::createOrUpdate($data);
+    $errors = $custom_field->getErrors();
+
+    if(!empty($errors)) {
+      return array(
+        'result' => false,
+        'errors' => $errors
+      );
+    } else {
+      return array(
+        'result' => true,
+        'field' => $custom_field->asArray()
+      );
+    }
+  }
+
+  function get($id) {
+    $custom_field = CustomField::findOne($id);
+    if($custom_field === false) {
+      return false;
+    } else {
+      return $custom_field->asArray();
+    }
+  }
+}

lib/API/Endpoints/Forms.php

@@ -0,0 +1,250 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+use \MailPoet\Models\Form;
+use \MailPoet\Models\StatisticsForms;
+use \MailPoet\Form\Renderer as FormRenderer;
+use \MailPoet\Listing;
+use \MailPoet\Form\Util;
+
+if(!defined('ABSPATH')) exit;
+
+class Forms {
+  function __construct() {
+  }
+
+  function get($id = false) {
+    $form = Form::findOne($id);
+    if($form !== false) {
+      $form = $form->asArray();
+    }
+    return $form;
+  }
+
+  function listing($data = array()) {
+    $listing = new Listing\Handler(
+      '\MailPoet\Models\Form',
+      $data
+    );
+
+    $listing_data = $listing->get();
+
+    // fetch segments relations for each returned item
+    foreach($listing_data['items'] as $key => $form) {
+      $form = $form->asArray();
+
+      $form['signups'] = StatisticsForms::getTotalSignups($form['id']);
+
+      $form['segments'] = (
+        !empty($form['settings']['segments'])
+        ? $form['settings']['segments']
+        : array()
+      );
+      $listing_data['items'][$key] = $form;
+    }
+
+    return $listing_data;
+  }
+
+  function create() {
+    // create new form
+    $form_data = array(
+      'name' => __('New form'),
+      'body' => array(
+        array(
+          'id' => 'email',
+          'name' => __('Email'),
+          'type' => 'text',
+          'static' => true,
+          'params' => array(
+            'label' => __('Email'),
+            'required' => true
+          )
+        ),
+        array(
+          'id' => 'submit',
+          'name' => __('Submit'),
+          'type' => 'submit',
+          'static' => true,
+          'params' => array(
+            'label' => __('Subscribe!')
+          )
+        )
+      ),
+      'settings' => array(
+        'on_success' => 'message',
+        'success_message' => __('Check your inbox or spam folder to confirm your subscription.'),
+        'segments' => null,
+        'segments_selected_by' => 'admin'
+      )
+    );
+
+    return $this->save($form_data);
+  }
+
+  function save($data = array()) {
+    $form = Form::createOrUpdate($data);
+    $errors = $form->getErrors();
+
+    if(!empty($errors)) {
+      return array(
+        'result' => false,
+        'errors' => $errors
+      );
+    } else {
+      return array(
+        'result' => true,
+        'form_id' => $form->id()
+      );
+    }
+  }
+
+  function previewEditor($data = array()) {
+    // html
+    $html = FormRenderer::renderHTML($data);
+
+    // convert shortcodes
+    $html = do_shortcode($html);
+
+    // styles
+    $css = new Util\Styles(FormRenderer::getStyles($data));
+
+    return array(
+      'html' => $html,
+      'css' => $css->render()
+    );
+  }
+
+  function exportsEditor($id) {
+    $exports = false;
+
+    $form = Form::findOne($id);
+
+    if($form !== false) {
+      $exports = Util\Export::getAll($form->asArray());
+    }
+
+    return $exports;
+  }
+
+  function saveEditor($data = array()) {
+    $form_id = (isset($data['id']) ? (int)$data['id'] : 0);
+    $name = (isset($data['name']) ? $data['name'] : __('New form'));
+    $body = (isset($data['body']) ? $data['body'] : array());
+    $settings = (isset($data['settings']) ? $data['settings'] : array());
+    $styles = (isset($data['styles']) ? $data['styles'] : '');
+
+    if(empty($body) || empty($settings)) {
+      // error
+      return false;
+    } else {
+      // check if the form is used as a widget
+      $is_widget = false;
+      $widgets = get_option('widget_mailpoet_form');
+      if(!empty($widgets)) {
+        foreach($widgets as $widget) {
+          if(isset($widget['form']) && (int)$widget['form'] === $form_id) {
+            $is_widget = true;
+            break;
+          }
+        }
+      }
+
+      // check if the user gets to pick his own lists
+      // or if it's selected by the admin
+      $has_segment_selection = false;
+
+      foreach($body as $i => $block) {
+        if($block['type'] === 'segment') {
+          $has_segment_selection = true;
+          if(!empty($block['params']['values'])) {
+            $list_selection = array_filter(
+              array_map(function($segment) {
+                return (isset($segment['id'])
+                  ? (int)$segment['id']
+                  : null
+                );
+              }, $block['params']['values'])
+            );
+          }
+          break;
+        }
+      }
+
+      // check list selection
+      if($has_segment_selection === true) {
+        $settings['segments_selected_by'] = 'user';
+      } else {
+        $settings['segments_selected_by'] = 'admin';
+      }
+    }
+
+    $form = Form::createOrUpdate(array(
+      'id' => $form_id,
+      'name' => $name,
+      'body' => $body,
+      'settings' => $settings,
+      'styles' => $styles
+    ));
+
+    if($form->getErrors() === false) {
+      return array(
+        'result' => true,
+        'is_widget' => $is_widget
+      );
+    } else {
+      return array(
+        'result' => false,
+        'errors' => $form->getErrors()
+      );
+    }
+  }
+
+  function restore($id) {
+    $form = Form::findOne($id);
+    if($form !== false) {
+      $form->restore();
+    }
+    return ($form->getErrors() === false);
+  }
+
+  function trash($id) {
+    $form = Form::findOne($id);
+    if($form !== false) {
+      $form->trash();
+    }
+    return ($form->getErrors() === false);
+  }
+
+  function delete($id) {
+    $form = Form::findOne($id);
+    if($form !== false) {
+      $form->delete();
+      return 1;
+    }
+    return false;
+  }
+
+  function duplicate($id) {
+    $result = false;
+
+    $form = Form::findOne($id);
+    if($form !== false) {
+      $data = array(
+        'name' => sprintf(__('Copy of %s'), $form->name)
+      );
+      $result = $form->duplicate($data)->asArray();
+    }
+
+    return $result;
+  }
+
+  function bulkAction($data = array()) {
+    $bulk_action = new Listing\BulkAction(
+      '\MailPoet\Models\Form',
+      $data
+    );
+
+    return $bulk_action->apply();
+  }
+}

lib/API/Endpoints/ImportExport.php

@@ -0,0 +1,64 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+use MailPoet\Subscribers\ImportExport\Import\MailChimp;
+use MailPoet\Models\CustomField;
+use MailPoet\Models\Segment;
+
+if(!defined('ABSPATH')) exit;
+
+class ImportExport {
+  function getMailChimpLists($data) {
+    $mailChimp = new MailChimp($data['api_key']);
+    return $mailChimp->getLists();
+  }
+
+  function getMailChimpSubscribers($data) {
+    $mailChimp = new MailChimp($data['api_key']);
+    return $mailChimp->getSubscribers($data['lists']);
+  }
+
+  function addSegment($data) {
+    $segment = Segment::createOrUpdate($data);
+    return (
+      ($segment->id) ?
+        array(
+          'result' => true,
+          'segment' => $segment->asArray()
+        ) :
+        array(
+          'result' => false
+        )
+    );
+  }
+
+  function addCustomField($data) {
+    $customField = CustomField::create();
+    $customField->hydrate($data);
+    $result = $customField->save();
+    return (
+      ($result) ?
+        array(
+          'result' => true,
+          'customField' => $customField->asArray()
+        ) :
+        array(
+          'result' => false
+        )
+    );
+  }
+
+  function processImport($data) {
+    $import = new \MailPoet\Subscribers\ImportExport\Import\Import(
+      json_decode($data, true)
+    );
+    return $import->process();
+  }
+
+  function processExport($data) {
+    $export = new \MailPoet\Subscribers\ImportExport\Export\Export(
+      json_decode($data, true)
+    );
+    return $export->process();
+  }
+}

lib/API/Endpoints/Mailer.php

@@ -0,0 +1,23 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+if(!defined('ABSPATH')) exit;
+
+class Mailer {
+  function send($data) {
+    $response = array();
+    try {
+      $mailer = new \MailPoet\Mailer\Mailer(
+        (isset($data['mailer'])) ? $data['mailer'] : false,
+        (isset($data['sender'])) ? $data['sender'] : false,
+        (isset($data['reply_to'])) ? $data['reply_to'] : false
+      );
+      $result = $mailer->send($data['newsletter'], $data['subscriber']);
+    } catch(\Exception $e) {
+      $result = false;
+      $response['errors'] = array($e->getMessage());
+    }
+    $response['result'] = ($result) ? true : false;
+    return $response;
+  }
+}

lib/API/Endpoints/NewsletterTemplates.php

@@ -0,0 +1,41 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+use MailPoet\Models\NewsletterTemplate;
+
+if(!defined('ABSPATH')) exit;
+
+class NewsletterTemplates {
+  function __construct() {
+  }
+
+  function get($id = false) {
+    $template = NewsletterTemplate::findOne($id);
+    if($template === false) {
+      return false;
+    } else {
+      return $template->asArray();
+    }
+  }
+
+  function getAll() {
+    $collection = NewsletterTemplate::findMany();
+    return array_map(function($item) {
+      return $item->asArray();
+    }, $collection);
+  }
+
+  function save($data = array()) {
+    $template = NewsletterTemplate::createOrUpdate($data);
+    return ($template->getErrors() === false && $template->id() > 0);
+  }
+
+  function delete($id) {
+    $template = NewsletterTemplate::findOne($id);
+    if($template !== false) {
+      return $template->delete();
+    } else {
+      return false;
+    }
+  }
+}

lib/API/Endpoints/Newsletters.php

@@ -0,0 +1,350 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+use MailPoet\Listing;
+use MailPoet\Models\Newsletter;
+use MailPoet\Models\Setting;
+use MailPoet\Models\NewsletterTemplate;
+use MailPoet\Models\NewsletterSegment;
+use MailPoet\Models\NewsletterOptionField;
+use MailPoet\Models\NewsletterOption;
+use MailPoet\Models\Subscriber;
+use MailPoet\Newsletter\Renderer\Renderer;
+use MailPoet\Newsletter\Scheduler\Scheduler;
+use MailPoet\Newsletter\Url as NewsletterUrl;
+use MailPoet\Util\Helpers;
+
+if(!defined('ABSPATH')) exit;
+
+require_once(ABSPATH . 'wp-includes/pluggable.php');
+
+class Newsletters {
+  function __construct() {
+  }
+
+  function get($id = false) {
+    $newsletter = Newsletter::findOne($id);
+    if($newsletter === false) {
+      return false;
+    } else {
+      $segments = $newsletter->segments()->findArray();
+      $options = $newsletter->options()->findArray();
+      $newsletter = $newsletter->asArray();
+      $newsletter['segments'] = array_map(function($segment) {
+        return $segment['id'];
+      }, $segments);
+      $newsletter['options'] = Helpers::arrayColumn($options, 'value', 'name');
+      return $newsletter;
+    }
+  }
+
+  function save($data = array()) {
+    $segment_ids = array();
+    if(isset($data['segments'])) {
+      $segment_ids = $data['segments'];
+      unset($data['segments']);
+    }
+
+    $options = array();
+    if(isset($data['options'])) {
+      $options = $data['options'];
+      unset($data['options']);
+    }
+
+    $newsletter = Newsletter::createOrUpdate($data);
+    $errors = $newsletter->getErrors();
+
+    if(!empty($errors)) {
+      return array(
+        'result' => false,
+        'errors' => $errors
+      );
+    } else {
+      if(!empty($segment_ids)) {
+        NewsletterSegment::where('newsletter_id', $newsletter->id)
+          ->deleteMany();
+
+        foreach($segment_ids as $segment_id) {
+          $relation = NewsletterSegment::create();
+          $relation->segment_id = $segment_id;
+          $relation->newsletter_id = $newsletter->id;
+          $relation->save();
+        }
+      }
+
+      if(!empty($options)) {
+        NewsletterOption::where('newsletter_id', $newsletter->id)
+          ->deleteMany();
+
+        $option_fields = NewsletterOptionField::where(
+          'newsletter_type',
+          $data['type']
+        )->findArray();
+
+        foreach($option_fields as $option_field) {
+          if(isset($options[$option_field['name']])) {
+            $relation = NewsletterOption::create();
+            $relation->newsletter_id = $newsletter->id;
+            $relation->option_field_id = $option_field['id'];
+            $relation->value = $options[$option_field['name']];
+            $relation->save();
+          }
+        }
+      }
+
+      return array(
+        'result' => true
+      );
+    }
+  }
+
+  function setStatus($data = array()) {
+    $id = (isset($data['id'])) ? (int)$data['id'] : null;
+    $newsletter = Newsletter::findOne($id);
+    $status = (isset($data['status']) ? $data['status'] : null);
+
+    $result = false;
+    $errors = array();
+
+    if($newsletter !== false && $status !== null) {
+      $newsletter->setStatus($status);
+
+      $result = (
+        $newsletter->getErrors() === false && $newsletter->status === $status
+      );
+    }
+
+    return array(
+      'result' => $result,
+      'status' => $newsletter->status
+    );
+  }
+
+  function restore($id) {
+    $newsletter = Newsletter::findOne($id);
+    if($newsletter !== false) {
+      $newsletter->restore();
+    }
+    return ($newsletter->getErrors() === false);
+  }
+
+  function trash($id) {
+    $newsletter = Newsletter::findOne($id);
+    if($newsletter !== false) {
+      $newsletter->trash();
+    }
+    return ($newsletter->getErrors() === false);
+  }
+
+  function delete($id) {
+    $newsletter = Newsletter::findOne($id);
+    if($newsletter !== false) {
+      $newsletter->delete();
+      return 1;
+    }
+    return false;
+  }
+
+  function duplicate($id = false) {
+    $result = false;
+
+    $newsletter = Newsletter::findOne($id);
+    if($newsletter !== false) {
+      $duplicate = $newsletter->duplicate(array(
+        'subject' => sprintf(__('Copy of %s'), $newsletter->subject)
+      ));
+
+      if($duplicate !== false && $duplicate->getErrors() === false) {
+        $result = $duplicate->asArray();
+      }
+    }
+    return $result;
+  }
+
+  function showPreview($data = array()) {
+    if(!isset($data['body'])) {
+      return array(
+        'result' => false,
+        'errors' => array(__('Newsletter data is missing'))
+      );
+    }
+    $newsletter_id = (isset($data['id'])) ? (int)$data['id'] : null;
+    $newsletter = Newsletter::findOne($newsletter_id);
+    if(!$newsletter) {
+      return array(
+        'result' => false,
+        'errors' => array(__('Newsletter could not be read'))
+      );
+    }
+    $newsletter->body = $data['body'];
+    $newsletter->save();
+    $wp_user = wp_get_current_user();
+    $subscriber = Subscriber::where('email', $wp_user->data->user_email)
+      ->findOne();
+    $subscriber = ($subscriber) ? $subscriber->asArray() : $subscriber;
+    $preview_url = NewsletterUrl::getViewInBrowserUrl($data, $subscriber);
+    return array(
+      'result' => true,
+      'data' => array('url' => $preview_url)
+    );
+  }
+
+  function sendPreview($data = array()) {
+    $id = (isset($data['id'])) ? (int)$data['id'] : null;
+    $newsletter = Newsletter::findOne($id);
+
+    if($newsletter === false) {
+      return array(
+        'result' => false
+      );
+    }
+    if(empty($data['subscriber'])) {
+      return array(
+        'result' => false,
+        'errors' => array(__('Please specify receiver information.'))
+      );
+    }
+
+    $newsletter = $newsletter->asArray();
+
+    $renderer = new Renderer($newsletter);
+    $rendered_newsletter = $renderer->render();
+    $divider = '***MailPoet***';
+    $data_for_shortcodes =
+      array_merge(array($newsletter['subject']), $rendered_newsletter);
+    $body = implode($divider, $data_for_shortcodes);
+
+    $wp_user = wp_get_current_user();
+    $subscriber = Subscriber::findOne($wp_user->data->user_email);
+    $subscriber = ($subscriber) ? $subscriber->asArray() : false;
+
+    $shortcodes = new \MailPoet\Newsletter\Shortcodes\Shortcodes(
+      $newsletter,
+      $subscriber
+    );
+    list($newsletter['subject'],
+      $newsletter['body']['html'],
+      $newsletter['body']['text']
+      ) = explode($divider, $shortcodes->replace($body));
+
+    try {
+      $mailer = new \MailPoet\Mailer\Mailer(
+        $mailer = false,
+        $sender = false,
+        $reply_to = false
+      );
+      $result = $mailer->send($newsletter, $data['subscriber']);
+
+      return array('result' => $result);
+    } catch(\Exception $e) {
+      return array(
+        'result' => false,
+        'errors' => array($e->getMessage()),
+      );
+    }
+  }
+
+  function listing($data = array()) {
+
+    $listing = new Listing\Handler(
+      '\MailPoet\Models\Newsletter',
+      $data
+    );
+    $listing_data = $listing->get();
+
+    foreach($listing_data['items'] as $key => $newsletter) {
+
+      if($newsletter->type === Newsletter::TYPE_STANDARD) {
+        $newsletter
+          ->withSegments()
+          ->withSendingQueue()
+          ->withStatistics();
+      } else if($newsletter->type === Newsletter::TYPE_WELCOME) {
+        $newsletter
+          ->withOptions()
+          ->withTotalSent()
+          ->withStatistics();
+      } else if($newsletter->type === Newsletter::TYPE_NOTIFICATION) {
+        $newsletter
+          ->withOptions()
+          ->withSegments()
+          ->withChildrenCount();
+      } else if($newsletter->type === Newsletter::TYPE_NOTIFICATION_HISTORY) {
+        $newsletter
+          ->withSegments()
+          ->withSendingQueue()
+          ->withStatistics();
+      }
+
+      // get preview url
+      $newsletter->preview_url = NewsletterUrl::getViewInBrowserUrl($newsletter);
+
+      // convert object to array
+      $listing_data['items'][$key] = $newsletter->asArray();
+    }
+
+    return $listing_data;
+  }
+
+  function bulkAction($data = array()) {
+    $bulk_action = new Listing\BulkAction(
+      '\MailPoet\Models\Newsletter',
+      $data
+    );
+    return $bulk_action->apply();
+  }
+
+  function create($data = array()) {
+    $options = array();
+    if(isset($data['options'])) {
+      $options = $data['options'];
+      unset($data['options']);
+    }
+
+    $newsletter = Newsletter::createOrUpdate($data);
+
+    // try to load template data
+    $template_id = (!empty($data['template']) ? (int)$data['template'] : false);
+    $template = NewsletterTemplate::findOne($template_id);
+    if($template !== false) {
+      $newsletter->body = $template->body;
+    } else {
+      $newsletter->body = array();
+    }
+
+    $newsletter->save();
+    $errors = $newsletter->getErrors();
+    if(!empty($errors)) {
+      return array(
+        'result' => false,
+        'errors' =>$errors
+      );
+    } else {
+      if(!empty($options)) {
+        $option_fields = NewsletterOptionField::where(
+          'newsletter_type', $newsletter->type
+        )->findArray();
+
+        foreach($option_fields as $option_field) {
+          if(isset($options[$option_field['name']])) {
+            $relation = NewsletterOption::create();
+            $relation->newsletter_id = $newsletter->id;
+            $relation->option_field_id = $option_field['id'];
+            $relation->value = $options[$option_field['name']];
+            $relation->save();
+          }
+        }
+      }
+      if(!isset($data['id']) &&
+        isset($data['type']) &&
+        $data['type'] === 'notification'
+      ) {
+        Scheduler::processPostNotificationSchedule($newsletter->id);
+      }
+      return array(
+        'result' => true,
+        'newsletter' => $newsletter->asArray()
+      );
+    }
+  }
+}

lib/API/Endpoints/Segments.php

@@ -0,0 +1,116 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+use \MailPoet\Models\Segment;
+use \MailPoet\Models\SubscriberSegment;
+use \MailPoet\Models\SegmentFilter;
+use \MailPoet\Listing;
+use \MailPoet\Segments\WP;
+
+if(!defined('ABSPATH')) exit;
+
+class Segments {
+  function __construct() {
+  }
+
+  function get($id = false) {
+    $segment = Segment::findOne($id);
+    if($segment === false) {
+      return false;
+    } else {
+      return $segment->asArray();
+    }
+  }
+
+  function listing($data = array()) {
+    $listing = new Listing\Handler(
+      '\MailPoet\Models\Segment',
+      $data
+    );
+
+    $listing_data = $listing->get();
+
+    // fetch segments relations for each returned item
+    foreach($listing_data['items'] as $key => $segment) {
+      $segment->subscribers_url = admin_url(
+        'admin.php?page=mailpoet-subscribers#/filter[segment='.$segment->id.']'
+      );
+
+      $listing_data['items'][$key] = $segment
+        ->withSubscribersCount()
+        ->asArray();
+    }
+
+    return $listing_data;
+  }
+
+  function save($data = array()) {
+    $segment = Segment::createOrUpdate($data);
+    $errors = $segment->getErrors();
+
+    if(!empty($errors)) {
+      return array(
+        'result' => false,
+        'errors' => $errors
+      );
+    } else {
+      return array(
+        'result' => true
+      );
+    }
+  }
+
+  function restore($id) {
+    $segment = Segment::findOne($id);
+    if($segment !== false) {
+      $segment->restore();
+    }
+    return ($segment->getErrors() === false);
+  }
+
+  function trash($id) {
+    $segment = Segment::findOne($id);
+    if($segment !== false) {
+      $segment->trash();
+    }
+    return ($segment->getErrors() === false);
+  }
+
+  function delete($id) {
+    $segment = Segment::findOne($id);
+    if($segment !== false) {
+      $segment->delete();
+      return 1;
+    }
+    return false;
+  }
+
+  function duplicate($id) {
+    $result = false;
+
+    $segment = Segment::findOne($id);
+    if($segment !== false) {
+      $data = array(
+        'name' => sprintf(__('Copy of %s'), $segment->name)
+      );
+      $result = $segment->duplicate($data)->asArray();
+    }
+
+    return $result;
+  }
+
+  function synchronize() {
+    $result = WP::synchronizeUsers();
+
+    return $result;
+  }
+
+  function bulkAction($data = array()) {
+    $bulk_action = new Listing\BulkAction(
+      '\MailPoet\Models\Segment',
+      $data
+    );
+
+    return $bulk_action->apply();
+  }
+}

lib/API/Endpoints/SendingQueue.php

@@ -0,0 +1,177 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+use MailPoet\Mailer\Mailer;
+use MailPoet\Models\Newsletter;
+use MailPoet\Models\NewsletterOption;
+use MailPoet\Models\NewsletterOptionField;
+use MailPoet\Models\Setting;
+use MailPoet\Models\Subscriber;
+use MailPoet\Models\SubscriberSegment;
+use MailPoet\Newsletter\Scheduler\Scheduler;
+use MailPoet\Models\SendingQueue as SendingQueueModel;
+use MailPoet\Util\Helpers;
+
+if(!defined('ABSPATH')) exit;
+
+class SendingQueue {
+  function add($data) {
+    // check that the sending method has been configured properly
+    try {
+      new Mailer(false);
+    } catch(\Exception $e) {
+      return array(
+        'result' => false,
+        'errors' => array($e->getMessage())
+      );
+    }
+
+    // check that the newsletter exists
+    $newsletter = Newsletter::filter('filterWithOptions')
+      ->findOne($data['newsletter_id']);
+
+    if($newsletter === false) {
+      return array(
+        'result' => false,
+        'errors' => array(__('This newsletter does not exist'))
+      );
+    }
+
+    if($newsletter->type === Newsletter::TYPE_WELCOME ||
+       $newsletter->type === Newsletter::TYPE_NOTIFICATION
+    ) {
+      // set newsletter status to active
+      $result = $newsletter->setStatus(Newsletter::STATUS_ACTIVE);
+      $errors = $result->getErrors();
+
+      if(!empty($errors)) {
+        return array(
+          'result' => false,
+          'errors' => $errors
+        );
+      } else {
+        $message = ($newsletter->type === Newsletter::TYPE_WELCOME) ?
+          __('Your Welcome Email has been activated') :
+          __('Your Post Notification has been activated');
+        return array(
+          'result' => true,
+          'data' => array(
+            'message' => $message
+          )
+        );
+      }
+    }
+
+    $queue = SendingQueueModel::whereNull('status')
+      ->where('newsletter_id', $newsletter->id)
+      ->findOne();
+
+    if(!empty($queue)) {
+      return array(
+        'result' => false,
+        'errors' => array(__('This newsletter is already being sent'))
+      );
+    }
+
+    $queue = SendingQueueModel::where('newsletter_id', $newsletter->id)
+      ->where('status', SendingQueueModel::STATUS_SCHEDULED)
+      ->findOne();
+    if(!$queue) {
+      $queue = SendingQueueModel::create();
+      $queue->newsletter_id = $newsletter->id;
+    }
+
+    if((bool)$newsletter->isScheduled) {
+      // set newsletter status
+      $newsletter->setStatus(Newsletter::STATUS_SCHEDULED);
+
+      // set queue status
+      $queue->status = SendingQueueModel::STATUS_SCHEDULED;
+      $queue->scheduled_at = Scheduler::scheduleFromTimestamp(
+        $newsletter->scheduledAt
+      );
+      $queue->subscribers = null;
+      $queue->count_total = $queue->count_to_process = 0;
+
+      $message = __('The newsletter has been scheduled');
+    } else {
+      $segments = $newsletter->segments()->findArray();
+      $segment_ids = array_map(function($segment) {
+        return $segment['id'];
+      }, $segments);
+      $subscribers = Subscriber::getSubscribedInSegments($segment_ids)
+        ->findArray();
+      $subscribers = Helpers::arrayColumn($subscribers, 'subscriber_id');
+      $subscribers = array_unique($subscribers);
+      if(!count($subscribers)) {
+        return array(
+          'result' => false,
+          'errors' => array(__('There are no subscribers in that list!'))
+        );
+      }
+      $queue->status = null;
+      $queue->scheduled_at = null;
+      $queue->subscribers = serialize(
+        array(
+          'to_process' => $subscribers
+        )
+      );
+      $queue->count_total = $queue->count_to_process = count($subscribers);
+
+      // set newsletter status
+      $newsletter->setStatus(Newsletter::STATUS_SENDING);
+
+      $message = __('The newsletter is being sent...');
+    }
+    $queue->save();
+
+    $errors = $queue->getErrors();
+    if(!empty($errors)) {
+      return array(
+        'result' => false,
+        'errors' => $errors
+      );
+    } else {
+      return array(
+        'result' => true,
+        'data' => array(
+          'message' => $message
+        )
+      );
+    }
+  }
+
+  function pause($newsletter_id) {
+    $newsletter = Newsletter::findOne($newsletter_id);
+    $result = false;
+
+    if($newsletter !== false) {
+      $queue = $newsletter->getQueue();
+
+      if($queue !== false) {
+        $result = $queue->pause();
+      }
+    }
+
+    return array(
+      'result' => $result
+    );
+  }
+
+  function resume($newsletter_id) {
+    $newsletter = Newsletter::findOne($newsletter_id);
+    $result = false;
+
+    if($newsletter !== false) {
+      $queue = $newsletter->getQueue();
+
+      if($queue !== false) {
+        $result = $queue->resume();
+      }
+    }
+
+    return array(
+      'result' => $result
+    );
+  }
+}

lib/API/Endpoints/Settings.php

@@ -0,0 +1,27 @@
+<?php
+namespace MailPoet\API\Endpoints;
+use \MailPoet\API\Endpoint as APIEndpoint;
+use \MailPoet\Models\Setting;
+
+if(!defined('ABSPATH')) exit;
+
+class Settings extends APIEndpoint {
+  function __construct() {
+  }
+
+  function get() {
+    $settings = Setting::getAll();
+    return $this->successResponse($settings);
+  }
+
+  function set($settings = array()) {
+    if(empty($settings)) {
+      return $this->badRequest();
+    } else {
+      foreach($settings as $name => $value) {
+        Setting::setValue($name, $value);
+      }
+      return $this->successResponse(Setting::getAll());
+    }
+  }
+}

lib/API/Endpoints/Setup.php

@@ -0,0 +1,24 @@
+<?php
+namespace MailPoet\API\Endpoints;
+use \MailPoet\Config\Activator;
+
+if(!defined('ABSPATH')) exit;
+
+class Setup {
+  function __construct() {
+  }
+
+  function reset() {
+    try {
+      $activator = new Activator();
+      $activator->deactivate();
+      $activator->activate();
+      $result = true;
+    } catch(\Exception $e) {
+      $result = false;
+    }
+    return array(
+      'result' => $result
+    );
+  }
+}

lib/API/Endpoints/Subscribers.php

@@ -0,0 +1,184 @@
+<?php
+namespace MailPoet\API\Endpoints;
+
+use MailPoet\Listing;
+use MailPoet\Models\Subscriber;
+use MailPoet\Models\SubscriberSegment;
+use MailPoet\Models\SubscriberCustomField;
+use MailPoet\Models\Segment;
+use MailPoet\Models\Setting;
+use MailPoet\Models\Form;
+use MailPoet\Models\StatisticsForms;
+use MailPoet\Util\Url;
+
+if(!defined('ABSPATH')) exit;
+
+class Subscribers {
+  function __construct() {
+  }
+
+  function get($id = null) {
+    $subscriber = Subscriber::findOne($id);
+    if($subscriber !== false) {
+      $subscriber = $subscriber
+        ->withCustomFields()
+        ->withSubscriptions()
+        ->asArray();
+    }
+    return $subscriber;
+  }
+
+  function listing($data = array()) {
+    $listing = new Listing\Handler(
+      '\MailPoet\Models\Subscriber',
+      $data
+    );
+
+    $listing_data = $listing->get();
+
+    // fetch segments relations for each returned item
+    foreach($listing_data['items'] as $key => $subscriber) {
+      $listing_data['items'][$key] = $subscriber
+        ->withSubscriptions()
+        ->asArray();
+    }
+
+    return $listing_data;
+  }
+
+  function save($data = array()) {
+    $subscriber = Subscriber::createOrUpdate($data);
+    $errors = $subscriber->getErrors();
+
+    if(!empty($errors)) {
+      return array(
+        'result' => false,
+        'errors' => $errors
+      );
+    } else {
+      return array(
+        'result' => true
+      );
+    }
+  }
+
+  function subscribe($data = array()) {
+    $doing_ajax = (bool)(defined('DOING_AJAX') && DOING_AJAX);
+    $errors = array();
+
+    $form = Form::findOne($data['form_id']);
+    unset($data['form_id']);
+    if($form === false || !$form->id()) {
+      $errors[] = __('This form does not exist');
+    }
+
+    $segment_ids = (!empty($data['segments'])
+      ? (array)$data['segments']
+      : array()
+    );
+    unset($data['segments']);
+
+    if(empty($segment_ids)) {
+      $errors[] = __('Please select a list');
+    }
+
+    if(!empty($errors)) {
+      return array(
+        'result' => false,
+        'errors' => $errors
+      );
+    }
+
+    $subscriber = Subscriber::subscribe($data, $segment_ids);
+    $errors = $subscriber->getErrors();
+    $result = ($errors === false && $subscriber->id() > 0);
+
+    // record form statistics
+    if($result === true && $form !== false && $form->id > 0) {
+      StatisticsForms::record($form->id, $subscriber->id);
+    }
+
+    // get success message to display after subscription
+    $form_settings = (
+      isset($form->settings)
+      ? unserialize($form->settings)
+      : null
+    );
+
+    if($form_settings !== null) {
+      switch($form_settings['on_success']) {
+        case 'page':
+          $success_page_url = get_permalink($form_settings['success_page']);
+
+          // response depending on context
+          if($doing_ajax === true) {
+            return array(
+              'result' => $result,
+              'page' => $success_page_url,
+              'errors' => $errors
+            );
+          } else {
+            if($result === false) {
+              Url::redirectBack();
+            } else {
+              Url::redirectTo($success_page_url);
+            }
+          }
+          break;
+
+        case 'message':
+        default:
+          // response depending on context
+          if($doing_ajax === true) {
+            return array(
+              'result' => $result,
+              'errors' => $errors
+            );
+          } else {
+            $params = (
+              ($result === true)
+              ? array('mailpoet_success' => $form->id)
+              : array()
+            );
+
+            Url::redirectBack($params);
+          }
+          break;
+      }
+    }
+  }
+
+  function restore($id) {
+    $subscriber = Subscriber::findOne($id);
+    if($subscriber !== false) {
+      $subscriber->restore();
+    }
+    return ($subscriber->getErrors() === false);
+  }
+
+  function trash($id) {
+    $subscriber = Subscriber::findOne($id);
+    if($subscriber !== false) {
+      $subscriber->trash();
+    }
+    return ($subscriber->getErrors() === false);
+  }
+
+  function delete($id) {
+    $subscriber = Subscriber::findOne($id);
+    if($subscriber !== false) {
+      $subscriber->delete();
+      return 1;
+    }
+    return false;
+  }
+
+  function bulkAction($data = array()) {
+    $bulk_action = new Listing\BulkAction(
+      '\MailPoet\Models\Subscriber',
+      $data
+    );
+
+    return $bulk_action->apply();
+  }
+}