2042 lines
66 KiB
PHP
2042 lines
66 KiB
PHP
<?php
|
|
/**
|
|
* Since 2013 Ovidiu Cimpean.
|
|
*
|
|
* Ovidiu Cimpean - Newsletter Pro © All rights reserved.
|
|
*
|
|
* DISCLAIMER
|
|
*
|
|
* Do not edit, modify or copy this file.
|
|
* If you wish to customize it, contact us at addons4prestashop@gmail.com.
|
|
*
|
|
* @author Ovidiu Cimpean <addons4prestashop@gmail.com>
|
|
* @copyright Since 2013 Ovidiu Cimpean
|
|
* @license Do not edit, modify or copy this file
|
|
*
|
|
* @version Release: 4
|
|
*/
|
|
|
|
use PQNP\Config;
|
|
use PQNP\Event;
|
|
|
|
class NewsletterProMailChimpController extends NewsletterProMailChimp
|
|
{
|
|
public $module;
|
|
public $id_list;
|
|
public $id_grouping;
|
|
|
|
public $api3;
|
|
|
|
public $sync_step = 500;
|
|
|
|
private $response;
|
|
|
|
public static $instance;
|
|
|
|
const ERROR_NO_LIST = 100;
|
|
const ERROR_NO_GROUPING = 101;
|
|
const ERROR_NO_CUSTOMERS_GROUP = 102;
|
|
const ERROR_DELITING_GROUP = 103;
|
|
const ERROR_CREATE_GROUP = 104;
|
|
const ERROR_CHIMP_UPDATE_NAME = 105;
|
|
|
|
const CONFIG_NAME = 'CHIMP';
|
|
const GROUPINGS_NAME = 'Customer Group';
|
|
|
|
public function __construct($key = null)
|
|
{
|
|
$self = $this;
|
|
|
|
if (is_null($key)) {
|
|
$key = pqnp_config_get('CHIMP.API_KYE', '');
|
|
}
|
|
self::$instance = &$this;
|
|
parent::__construct($key);
|
|
|
|
$this->module = NewsletterPro::getInstance();
|
|
|
|
$this->initInitConfiguration();
|
|
|
|
$this->id_list = pqnp_config('CHIMP.ID_LIST');
|
|
$this->id_grouping = pqnp_config('CHIMP.ID_GROUPING');
|
|
$this->api3 = new NewsletterProMailChimpApi3($key);
|
|
|
|
$this->response = NewsletterProAjaxResponse::newInstance();
|
|
|
|
Event::listen(Config::EVENT_CONFIG_SET, function ($data) use ($self) {
|
|
if ('CHIMP.ID_LIST' === $data['path']) {
|
|
$self->id_list = $data['value'];
|
|
} elseif ('CHIMP.ID_GROUPING' === $data['path']) {
|
|
$self->id_grouping = $data['value'];
|
|
}
|
|
});
|
|
}
|
|
|
|
public function install()
|
|
{
|
|
return $this->installFields() && $this->installGrouping(self::GROUPINGS_NAME);
|
|
}
|
|
|
|
public function uninstall()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public function initInitConfiguration()
|
|
{
|
|
if (isset($this->module->ini_config)) {
|
|
$config = $this->module->ini_config;
|
|
if (isset($config['chimp_sync_step'])) {
|
|
$this->sync_step = (int) $config['chimp_sync_step'];
|
|
}
|
|
}
|
|
}
|
|
|
|
public function getInstance()
|
|
{
|
|
return self::$instance;
|
|
}
|
|
|
|
public function isInstalled()
|
|
{
|
|
return pqnp_config('CHIMP.INSTALLED');
|
|
}
|
|
|
|
public function installConfiguration($api_key, $list_id)
|
|
{
|
|
pqnp_config('CHIMP', array_merge(Config::defaultConfig('CHIMP'), [
|
|
'INSTALLED' => true,
|
|
'API_KYE' => $api_key,
|
|
'ID_LIST' => $list_id,
|
|
]));
|
|
|
|
$this->id_list = $list_id;
|
|
$this->updateApiKey($api_key);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function installGrouping($grouping_name)
|
|
{
|
|
$shop_config = $this->getShopConfig();
|
|
|
|
$shop_groups = $shop_config['groups'];
|
|
$grouping_creation = self::grep($shop_groups, 'name');
|
|
|
|
$id_list = $this->id_list;
|
|
|
|
$response = $this->api3->call("lists/{$id_list}/interest-categories", [], 'GET');
|
|
|
|
if (!$response->success()) {
|
|
$err = $response->getErrors(true);
|
|
$this->mergeErrors($err);
|
|
|
|
return false;
|
|
}
|
|
|
|
$grouping = $response->getContent();
|
|
$categories = $grouping['categories'];
|
|
|
|
if (count($categories) > 0) {
|
|
$category = array_filter($categories, function ($category) use ($grouping_name) {
|
|
return $category['title'] === $grouping_name;
|
|
});
|
|
|
|
if (count($category) > 0) {
|
|
$category = $category[0];
|
|
$interest_category_id = $category['id'];
|
|
$this->id_grouping = $interest_category_id;
|
|
|
|
$response = $this->api3->call("/lists/{$id_list}/interest-categories/{$interest_category_id}/interests", [], 'GET');
|
|
|
|
if (!$response->success()) {
|
|
$err = $response->getErrors(true);
|
|
$this->mergeErrors($err);
|
|
|
|
return false;
|
|
}
|
|
|
|
$interests = array_map(function ($item) {
|
|
return [
|
|
'id' => $item['id'],
|
|
'name' => $item['name'],
|
|
];
|
|
}, $response->getContent('interests'));
|
|
|
|
$this->writeGroupsConfig($this->id_list, $this->id_grouping);
|
|
|
|
$groups_name = array_map(function ($item) {
|
|
return $item['name'];
|
|
}, $interests);
|
|
|
|
$groups_name_remove = array_diff($groups_name, $grouping_creation);
|
|
$groups_name_add = array_diff($grouping_creation, $groups_name);
|
|
|
|
foreach ($interests as $int) {
|
|
if (in_array($int['name'], $groups_name_remove)) {
|
|
$id = $int['id'];
|
|
$response = $this->api3->call("/lists/{$id_list}/interest-categories/{$interest_category_id}/interests/{$id}", [], 'DELETE');
|
|
|
|
if (!$response->success()) {
|
|
$this->mergeErrors($response->getErrors(true));
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach ($groups_name_add as $name) {
|
|
$response = $this->api3->call("/lists/{$id_list}/interest-categories/{$interest_category_id}/interests", [
|
|
'name' => $name,
|
|
], 'POST');
|
|
|
|
if (!$response->success()) {
|
|
$this->mergeErrors($response->getErrors(true));
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
$response = $this->api3->call("/lists/{$id_list}/interest-categories", [
|
|
'title' => $grouping_name,
|
|
'type' => 'checkboxes',
|
|
], 'POST');
|
|
|
|
if (!$response->success()) {
|
|
$err = $response->getErrors(true);
|
|
$this->mergeErrors($err);
|
|
|
|
return false;
|
|
}
|
|
|
|
$interest_category_id = $response->getContent('id');
|
|
$this->id_grouping = $interest_category_id;
|
|
|
|
pqnp_config('CHIMP.ID_GROUPING', $interest_category_id);
|
|
$this->writeGroupsConfig($this->id_list, $this->id_grouping);
|
|
|
|
foreach ($grouping_creation as $name) {
|
|
$response = $this->api3->call("/lists/{$id_list}/interest-categories/{$interest_category_id}/interests", [
|
|
'name' => $name,
|
|
], 'POST');
|
|
|
|
if (!$response->success()) {
|
|
$err = $response->getErrors(true);
|
|
$this->mergeErrors($err);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function getAddedSql($cfg = [])
|
|
{
|
|
$select = null;
|
|
$join = null;
|
|
$where = null;
|
|
$and = null;
|
|
$end = null;
|
|
|
|
extract($cfg);
|
|
|
|
$sql = 'SELECT n.`id_newsletter_pro_email` AS `id`,
|
|
n.`email`,
|
|
n.`firstname`,
|
|
n.`lastname`,
|
|
n.`id_shop`,
|
|
n.`id_lang`,
|
|
n.`date_add`,
|
|
n.`active`,
|
|
n.`ip_registration_newsletter` AS `ip`,
|
|
s.`name` AS `shop_name`,
|
|
l.`name` AS `language`,
|
|
l.`iso_code` AS `lang_iso`
|
|
';
|
|
$sql .= (isset($select) ? ' , '.$select.' ' : '');
|
|
$sql .= ' FROM `'._DB_PREFIX_.'newsletter_pro_email` n
|
|
LEFT JOIN `'._DB_PREFIX_.'lang` l ON (l.`id_lang` = n.`id_lang`)
|
|
LEFT JOIN `'._DB_PREFIX_.'shop` s ON (s.`id_shop` = n.`id_shop`) ';
|
|
$sql .= (isset($join) ? ' '.$join.' ' : '');
|
|
$sql .= (isset($where) ? ' WHERE '.$where.' ' : ' WHERE 1 ');
|
|
$sql .= !(int) pqnp_config('CHIMP_SYNC_UNSUBSCRIBED') ? ' AND n.`active` = 1 ' : '';
|
|
$sql .= (isset($and) ? ' AND '.$and.' ' : '');
|
|
$sql .= ' ORDER BY n.`id_newsletter_pro_email` ASC';
|
|
$sql .= (isset($end) ? ' '.$end.' ' : '');
|
|
$sql .= ';';
|
|
|
|
return $sql;
|
|
}
|
|
|
|
public function getVisitorsSql($cfg = [])
|
|
{
|
|
$select = null;
|
|
$join = null;
|
|
$where = null;
|
|
$and = null;
|
|
$end = null;
|
|
|
|
extract($cfg);
|
|
|
|
$tableName = NewsletterProDefaultNewsletterTable::getTableName();
|
|
if ($tableName) {
|
|
$sql = 'SELECT n.`id`, n.`id_shop`,
|
|
n.`ip_registration_newsletter` AS `ip`,
|
|
n.`newsletter_date_add` AS `date_add`,
|
|
n.`email`, n.`active`,
|
|
sh.`name` AS `shop_name`
|
|
';
|
|
|
|
$sql .= (isset($select) ? ' , '.$select.' ' : '');
|
|
|
|
$sql .= ' FROM `'._DB_PREFIX_.$tableName.'` n
|
|
INNER JOIN `'._DB_PREFIX_.'shop` sh ON (n.`id_shop` = sh.`id_shop`) ';
|
|
$sql .= (isset($join) ? ' '.$join.' ' : '');
|
|
|
|
$sql .= (isset($where) ? ' WHERE '.$where.' ' : ' WHERE 1 ');
|
|
$sql .= !(int) pqnp_config('CHIMP_SYNC_UNSUBSCRIBED') ? ' AND n.`active` = 1 ' : '';
|
|
$sql .= (isset($and) ? ' AND '.$and.' ' : '');
|
|
|
|
$sql .= ' ORDER BY n.`id` ASC ';
|
|
$sql .= (isset($end) ? ' '.$end.' ' : '');
|
|
$sql .= ';';
|
|
|
|
return $sql;
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
public function getVisitorsNPSql($cfg = [])
|
|
{
|
|
$select = null;
|
|
$join = null;
|
|
$where = null;
|
|
$and = null;
|
|
$end = null;
|
|
|
|
extract($cfg);
|
|
|
|
$sql = 'SELECT n.`id_newsletter_pro_subscribers` AS `id`,
|
|
n.`email`,
|
|
n.`birthday`,
|
|
n.`firstname`,
|
|
n.`lastname`,
|
|
n.`id_shop`,
|
|
n.`id_lang`,
|
|
n.`id_gender`,
|
|
n.`date_add`,
|
|
n.`active`,
|
|
n.`ip_registration_newsletter` AS `ip`,
|
|
s.`name` AS `shop_name`,
|
|
l.`name` AS `language`,
|
|
l.`iso_code` AS `lang_iso`
|
|
';
|
|
$sql .= (isset($select) ? ' , '.$select.' ' : '');
|
|
$sql .= ' FROM `'._DB_PREFIX_.'newsletter_pro_subscribers` n
|
|
LEFT JOIN `'._DB_PREFIX_.'lang` l ON (l.`id_lang` = n.`id_lang`)
|
|
LEFT JOIN `'._DB_PREFIX_.'shop` s ON (s.`id_shop` = n.`id_shop`) ';
|
|
$sql .= (isset($join) ? ' '.$join.' ' : '');
|
|
$sql .= (isset($where) ? ' WHERE '.$where.' ' : ' WHERE 1 ');
|
|
$sql .= !(int) pqnp_config('CHIMP_SYNC_UNSUBSCRIBED') ? ' AND n.`active` = 1 ' : '';
|
|
$sql .= (isset($and) ? ' AND '.$and.' ' : '');
|
|
$sql .= ' ORDER BY n.`id_newsletter_pro_subscribers` ASC';
|
|
$sql .= (isset($end) ? ' '.$end.' ' : '');
|
|
$sql .= ';';
|
|
|
|
return $sql;
|
|
}
|
|
|
|
public function getAdded($start_id = null, $limit = null)
|
|
{
|
|
$cfg = [];
|
|
|
|
if (isset($start_id)) {
|
|
$cfg['and'] = 'n.`id_newsletter_pro_email` >='.(int) $start_id;
|
|
}
|
|
|
|
if (isset($limit)) {
|
|
$cfg['end'] = 'LIMIT '.(int) $limit;
|
|
}
|
|
|
|
$sql = $this->getAddedSql($cfg);
|
|
$result = Db::getInstance()->executeS($sql);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function getAddedByDate($from, $to = null)
|
|
{
|
|
$and = ' n.`date_add` >= "'.pSQL($from).'" ';
|
|
if (isset($to)) {
|
|
$and .= ' AND n.`date_add` <= "'.pSQL($to).'" ';
|
|
}
|
|
|
|
$sql = $this->getAddedSql([
|
|
'and' => $and,
|
|
]);
|
|
$result = Db::getInstance()->executeS($sql);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function syncAddedByDate($from, $to = null)
|
|
{
|
|
$added = $this->getAddedByDate($from, $to);
|
|
$users = $this->getAddedUsers($added);
|
|
|
|
if (empty($users)) {
|
|
return $this->getSyncEmptyResonse();
|
|
} else {
|
|
return [
|
|
'db_users' => $added,
|
|
'chimp_response' => $this->subscribe($this->id_list, $users),
|
|
];
|
|
}
|
|
}
|
|
|
|
public function getAddedUsers($added)
|
|
{
|
|
$chimp_users = new NewsletterProMailChimpUsers();
|
|
foreach ($added as $add) {
|
|
$chimp_users->addUser([
|
|
'email' => $add['email'],
|
|
'firstname' => $add['firstname'],
|
|
'lastname' => $add['lastname'],
|
|
'shop' => $add['shop_name'],
|
|
'language' => $add['language'],
|
|
'user_type' => NewsletterProMailChimpUsers::USER_TYPE_ADDED,
|
|
'ip' => $add['ip'],
|
|
'lang_iso' => $add['lang_iso'],
|
|
'subscribed' => $add['active'],
|
|
'date_add' => $add['date_add'],
|
|
'date' => date('m/d/Y'),
|
|
]);
|
|
}
|
|
|
|
return $chimp_users->getUsers();
|
|
}
|
|
|
|
public function getVisitorsNPUsers($vistitors)
|
|
{
|
|
$chimp_users = new NewsletterProMailChimpUsers();
|
|
foreach ($vistitors as $vistitor) {
|
|
$chimp_users->addUser([
|
|
'email' => $vistitor['email'],
|
|
'birthday' => $vistitor['birthday'],
|
|
'firstname' => $vistitor['firstname'],
|
|
'lastname' => $vistitor['lastname'],
|
|
'shop' => $vistitor['shop_name'],
|
|
'language' => $vistitor['language'],
|
|
'user_type' => NewsletterProMailChimpUsers::USER_TYPE_VISITOR,
|
|
'ip' => $vistitor['ip'],
|
|
'lang_iso' => $vistitor['lang_iso'],
|
|
'subscribed' => $vistitor['active'],
|
|
'date_add' => $vistitor['date_add'],
|
|
'date' => date('m/d/Y'),
|
|
]);
|
|
}
|
|
|
|
return $chimp_users->getUsers();
|
|
}
|
|
|
|
public function syncAdded($start_id = null, $limit = null)
|
|
{
|
|
$added = $this->getAdded($start_id, $limit);
|
|
$users = $this->getAddedUsers($added);
|
|
|
|
if (empty($users)) {
|
|
return $this->getSyncEmptyResonse();
|
|
} else {
|
|
return [
|
|
'db_users' => $added,
|
|
'chimp_response' => $this->subscribe($this->id_list, $users),
|
|
];
|
|
}
|
|
}
|
|
|
|
public function getVisitorsByDate($from, $to = null)
|
|
{
|
|
$and = ' n.`newsletter_date_add` >= "'.pSQL($from).'" ';
|
|
if (isset($to)) {
|
|
$and .= ' AND n.`newsletter_date_add` <= "'.pSQL($to).'" ';
|
|
}
|
|
|
|
$sql = $this->getVisitorsSql([
|
|
'and' => $and,
|
|
]);
|
|
|
|
$result = Db::getInstance()->executeS($sql);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function getVisitorsNPByDate($from, $to = null)
|
|
{
|
|
$and = ' n.`date_add` >= "'.pSQL($from).'" ';
|
|
if (isset($to)) {
|
|
$and .= ' AND n.`date_add` <= "'.pSQL($to).'" ';
|
|
}
|
|
|
|
$sql = $this->getVisitorsNPSql([
|
|
'and' => $and,
|
|
]);
|
|
|
|
$result = Db::getInstance()->executeS($sql);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function getVisitors($start_id = null, $limit = null)
|
|
{
|
|
$cfg = [];
|
|
|
|
if (isset($start_id)) {
|
|
$cfg['and'] = 'n.`id` >='.(int) $start_id;
|
|
}
|
|
|
|
if (isset($limit)) {
|
|
$cfg['end'] = 'LIMIT '.(int) $limit;
|
|
}
|
|
|
|
$sql = $this->getVisitorsSql($cfg);
|
|
$result = Db::getInstance()->executeS($sql);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function getVisitorsNP($start_id = null, $limit = null)
|
|
{
|
|
$cfg = [];
|
|
|
|
if (isset($start_id)) {
|
|
$cfg['and'] = 'n.`id_newsletter_pro_subscribers` >='.(int) $start_id;
|
|
}
|
|
|
|
if (isset($limit)) {
|
|
$cfg['end'] = 'LIMIT '.(int) $limit;
|
|
}
|
|
|
|
$sql = $this->getVisitorsNPSql($cfg);
|
|
$result = Db::getInstance()->executeS($sql);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function countCustomers()
|
|
{
|
|
$sql = 'SELECT COUNT(*) FROM `'._DB_PREFIX_.'customer` WHERE 1 ';
|
|
$sql .= !(int) pqnp_config('CHIMP_SYNC_UNSUBSCRIBED') ? ' AND `newsletter` = 1 ' : '';
|
|
|
|
return Db::getInstance()->getValue($sql);
|
|
}
|
|
|
|
public function countOrders($from)
|
|
{
|
|
return Db::getInstance()->getValue('SELECT COUNT(*) FROM `'._DB_PREFIX_.'orders` WHERE `date_add` > "'.pSQL($from).'" ');
|
|
}
|
|
|
|
public function countVisitors()
|
|
{
|
|
$table_name = NewsletterProDefaultNewsletterTable::getTableName();
|
|
if (!$table_name) {
|
|
return 0;
|
|
}
|
|
|
|
$sql = 'SELECT COUNT(*) FROM `'.pSQL(_DB_PREFIX_.$table_name).'` WHERE 1 ';
|
|
$sql .= !(int) pqnp_config('CHIMP_SYNC_UNSUBSCRIBED') ? ' AND `active` = 1 ' : '';
|
|
|
|
return Db::getInstance()->getValue($sql);
|
|
}
|
|
|
|
public function countVisitorsNP()
|
|
{
|
|
$sql = 'SELECT COUNT(*) FROM `'._DB_PREFIX_.'newsletter_pro_subscribers` WHERE 1';
|
|
$sql .= !(int) pqnp_config('CHIMP_SYNC_UNSUBSCRIBED') ? ' AND `active` = 1 ' : '';
|
|
|
|
return Db::getInstance()->getValue($sql);
|
|
}
|
|
|
|
public function countAdded()
|
|
{
|
|
$sql = 'SELECT COUNT(*) FROM `'._DB_PREFIX_.'newsletter_pro_email` WHERE 1';
|
|
$sql .= !(int) pqnp_config('CHIMP_SYNC_UNSUBSCRIBED') ? ' AND `active` = 1 ' : '';
|
|
|
|
return Db::getInstance()->getValue($sql);
|
|
}
|
|
|
|
public function getCustomersSql($cfg = [])
|
|
{
|
|
$select = null;
|
|
$from = null;
|
|
$join = null;
|
|
$where = null;
|
|
$and = null;
|
|
$end = null;
|
|
|
|
extract($cfg);
|
|
|
|
$sql = 'SELECT c.`firstname`, c.`lastname`, c.`email`, c.`id_customer` AS `id`,
|
|
c.`id_lang`, c.`id_shop`, c.`id_default_group`, c.`newsletter`, sh.`name` AS `shop_name`,
|
|
GROUP_CONCAT(gl.`id_group`) AS `groups`,
|
|
npcc.`categories`,
|
|
c.`date_add`,
|
|
c.`birthday`,
|
|
lg.`name` AS `language`,
|
|
c.`ip_registration_newsletter` AS `ip`,
|
|
lg.`iso_code` AS `lang_iso`,
|
|
adr.`company` AS `company`,
|
|
adr.`lastname` AS `address_lastname`,
|
|
adr.`firstname` AS `address_firstname`,
|
|
adr.`address1` AS `address1`,
|
|
adr.`address2` AS `address2`,
|
|
adr.`postcode` AS `postcode`,
|
|
adr.`city` AS `city`,
|
|
adr.`phone` AS `phone`,
|
|
adr.`phone_mobile` AS `phone_mobile`,
|
|
cty.`iso_code` AS `country_iso`,
|
|
sta.`name` AS state,
|
|
po.`date_add` as `last_order` ';
|
|
|
|
$sql .= (isset($select) ? ', '.$select.' ' : '');
|
|
$sql .= ' FROM `'._DB_PREFIX_.'customer` c ';
|
|
$sql .= (isset($from) ? ' '.$from.' ' : '');
|
|
$sql .= ' LEFT JOIN `'._DB_PREFIX_.'customer_group` cg ON ( cg.`id_customer` = c.`id_customer` )
|
|
LEFT JOIN `'._DB_PREFIX_.'newsletter_pro_customer_category` npcc ON (c.`id_customer` = npcc.`id_customer`)
|
|
LEFT JOIN `'._DB_PREFIX_.'lang` lg ON (c.`id_lang` = lg.`id_lang`)
|
|
LEFT JOIN `'._DB_PREFIX_.'shop` sh ON (c.`id_shop` = sh.`id_shop`)
|
|
LEFT JOIN `'._DB_PREFIX_.'group_lang` gl ON (cg.`id_group` = gl.`id_group` AND gl.`id_lang` = '.(int) pqnp_config('PS_LANG_DEFAULT').' )
|
|
LEFT JOIN `'._DB_PREFIX_.'address` adr ON
|
|
(
|
|
c.`id_customer` = adr.`id_customer`
|
|
AND adr.id_address = (
|
|
SELECT MAX(id_address) FROM `'._DB_PREFIX_.'address`
|
|
WHERE `id_customer` = adr.`id_customer`
|
|
LIMIT 1
|
|
)
|
|
)
|
|
LEFT JOIN `'._DB_PREFIX_.'country` cty ON (cty.`id_country` = adr.`id_country`)
|
|
LEFT JOIN `'._DB_PREFIX_.'state` sta ON (sta.`id_state` = adr.`id_state`)
|
|
LEFT JOIN `'._DB_PREFIX_.'orders` po
|
|
ON (c.`id_customer` = po.`id_customer`
|
|
AND po.`date_add` = (
|
|
SELECT MAX(`date_add`)
|
|
FROM `'._DB_PREFIX_.'orders`
|
|
WHERE `id_customer` = po.`id_customer`
|
|
)
|
|
)
|
|
';
|
|
$sql .= (isset($join) ? ' '.$join.' ' : '');
|
|
|
|
$sql .= (isset($where) ? ' WHERE '.$where.' ' : ' WHERE 1 ');
|
|
|
|
$sql .= !(int) pqnp_config('CHIMP_SYNC_UNSUBSCRIBED') ? ' AND c.`newsletter` = 1 ' : '';
|
|
|
|
$sql .= (isset($and) ? ' AND '.$and.' ' : '');
|
|
|
|
$sql .= ' GROUP BY c.id_customer
|
|
ORDER BY c.`id_customer` ASC ';
|
|
$sql .= (isset($end) ? ' '.$end.' ' : '');
|
|
$sql .= ';';
|
|
|
|
return $sql;
|
|
}
|
|
|
|
public function getCustomers($start_id = null, $limit = null)
|
|
{
|
|
$cfg = [];
|
|
|
|
if (isset($start_id)) {
|
|
$cfg['and'] = 'c.`id_customer` >='.(int) $start_id;
|
|
}
|
|
|
|
if (isset($limit)) {
|
|
$cfg['end'] = 'LIMIT '.(int) $limit;
|
|
}
|
|
|
|
$sql = $this->getCustomersSql($cfg);
|
|
$result = Db::getInstance()->executeS($sql);
|
|
|
|
foreach ($result as &$row) {
|
|
$row['groups'] = implode(',', array_unique(explode(',', $row['groups'])));
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function getCustomersByDate($from, $to = null)
|
|
{
|
|
$and = ' c.`date_upd` >= "'.pSQL($from).'" ';
|
|
if (isset($to)) {
|
|
$and .= ' AND c.`date_upd` <= "'.pSQL($to).'" ';
|
|
}
|
|
|
|
$sql = $this->getCustomersSql([
|
|
'and' => $and,
|
|
]);
|
|
$result = Db::getInstance()->executeS($sql);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function getCustomersUsers($customers)
|
|
{
|
|
$chimp_users = new NewsletterProMailChimpUsers();
|
|
|
|
foreach ($customers as $customer) {
|
|
$groups = explode(',', trim($customer['groups'], ','));
|
|
|
|
if (isset($groups[0]) && !$groups[0]) {
|
|
$groups = [];
|
|
}
|
|
|
|
$chimp_users->addUser([
|
|
'email' => $customer['email'],
|
|
'firstname' => $customer['firstname'],
|
|
'lastname' => $customer['lastname'],
|
|
'shop' => $customer['shop_name'],
|
|
'language' => $customer['language'],
|
|
'user_type' => NewsletterProMailChimpUsers::USER_TYPE_CUSTOMER,
|
|
'ip' => $customer['ip'],
|
|
'lang_iso' => $customer['lang_iso'],
|
|
'phone' => $customer['phone'],
|
|
'phone_mobile' => $customer['phone_mobile'],
|
|
'company' => $customer['company'],
|
|
'subscribed' => $customer['newsletter'],
|
|
'birthday' => $customer['birthday'],
|
|
'last_order' => $customer['last_order'],
|
|
'date_add' => $customer['date_add'],
|
|
'date' => date('m/d/Y'),
|
|
'groups' => [
|
|
'id' => $this->id_grouping,
|
|
'groups' => $groups,
|
|
],
|
|
'address' => [
|
|
'addr1' => $customer['address1'],
|
|
'addr2' => $customer['address2'],
|
|
'city' => $customer['city'],
|
|
'state' => $customer['state'],
|
|
'zip' => $customer['postcode'],
|
|
'country' => $customer['country_iso'],
|
|
],
|
|
]);
|
|
}
|
|
|
|
return $chimp_users->getUsers();
|
|
}
|
|
|
|
public function getSyncEmptyResonse()
|
|
{
|
|
return [
|
|
'db_users' => [],
|
|
'chimp_response' => [
|
|
'adds' => [],
|
|
'updates' => [],
|
|
'errors' => [],
|
|
],
|
|
];
|
|
}
|
|
|
|
public function syncOrdersByDate($date)
|
|
{
|
|
// syncOrdersByDate
|
|
$orders = NewsletterProMailChimpOrder::getOrdersIdSinceDate($date);
|
|
|
|
if (empty($orders)) {
|
|
return $this->getSyncEmptyResonse();
|
|
} else {
|
|
$response = [];
|
|
foreach ($orders as $order) {
|
|
$id_order = $order['id_order'];
|
|
|
|
$mc_order = NewsletterProMailChimpOrder::newInstance($id_order, Configuration::get('PS_CURRENCY_DEFAULT'));
|
|
$response[$id_order] = $this->orderAdd($mc_order->toArray());
|
|
|
|
NewsletterProConfig::save('CHIMP_LAST_DATE_SYNC_ORDERS', $order['date_add']);
|
|
}
|
|
|
|
return [
|
|
'db_users' => $orders,
|
|
'chimp_response' => $response,
|
|
];
|
|
}
|
|
}
|
|
|
|
public function syncCustomersByDate($from, $to = null)
|
|
{
|
|
$customers = $this->getCustomersByDate($from, $to);
|
|
$users = $this->getCustomersUsers($customers);
|
|
|
|
if (empty($users)) {
|
|
return $this->getSyncEmptyResonse();
|
|
} else {
|
|
return [
|
|
'db_users' => $customers,
|
|
'chimp_response' => $this->subscribe($this->id_list, $users),
|
|
];
|
|
}
|
|
}
|
|
|
|
public function syncCustomers($start_id = null, $limit = null)
|
|
{
|
|
$customers = $this->getCustomers($start_id, $limit);
|
|
$users = $this->getCustomersUsers($customers);
|
|
|
|
if (empty($users)) {
|
|
return $this->getSyncEmptyResonse();
|
|
} else {
|
|
return [
|
|
'db_users' => $customers,
|
|
'chimp_response' => $this->subscribe($this->id_list, $users),
|
|
];
|
|
}
|
|
}
|
|
|
|
public function getVisitorsUsers($vistitors)
|
|
{
|
|
$default_language = Language::getLanguage((int) pqnp_config('PS_LANG_DEFAULT'));
|
|
|
|
$chimp_users = new NewsletterProMailChimpUsers();
|
|
foreach ($vistitors as $vistitor) {
|
|
$chimp_users->addUser([
|
|
'email' => $vistitor['email'],
|
|
'shop' => $vistitor['shop_name'],
|
|
'language' => $default_language['name'],
|
|
'user_type' => NewsletterProMailChimpUsers::USER_TYPE_VISITOR,
|
|
'ip' => $vistitor['ip'],
|
|
'lang_iso' => $default_language['iso_code'],
|
|
'subscribed' => $vistitor['active'],
|
|
'date_add' => $vistitor['date_add'],
|
|
'date' => date('m/d/Y'),
|
|
]);
|
|
}
|
|
|
|
return $chimp_users->getUsers();
|
|
}
|
|
|
|
public function syncVisitorsByDate($from, $to = null)
|
|
{
|
|
$vistitors = $this->getVisitorsByDate($from, $to);
|
|
$users = $this->getVisitorsUsers($vistitors);
|
|
|
|
if (empty($users)) {
|
|
return $this->getSyncEmptyResonse();
|
|
} else {
|
|
return [
|
|
'db_users' => $vistitors,
|
|
'chimp_response' => $this->subscribe($this->id_list, $users),
|
|
];
|
|
}
|
|
}
|
|
|
|
public function syncVisitorsNPByDate($from, $to = null)
|
|
{
|
|
$vistitors = $this->getVisitorsNPByDate($from, $to);
|
|
$users = $this->getVisitorsNPUsers($vistitors);
|
|
|
|
if (empty($users)) {
|
|
return $this->getSyncEmptyResonse();
|
|
} else {
|
|
return [
|
|
'db_users' => $vistitors,
|
|
'chimp_response' => $this->subscribe($this->id_list, $users),
|
|
];
|
|
}
|
|
}
|
|
|
|
public function syncVisitors($start_id = null, $limit = null)
|
|
{
|
|
$vistitors = $this->getVisitors($start_id, $limit);
|
|
$users = $this->getVisitorsUsers($vistitors);
|
|
|
|
if (empty($users)) {
|
|
return $this->getSyncEmptyResonse();
|
|
} else {
|
|
return [
|
|
'db_users' => $vistitors,
|
|
'chimp_response' => $this->subscribe($this->id_list, $users),
|
|
];
|
|
}
|
|
}
|
|
|
|
public function syncVisitorsNP($start_id = null, $limit = null)
|
|
{
|
|
$vistitors = $this->getVisitorsNP($start_id, $limit);
|
|
$users = $this->getVisitorsNPUsers($vistitors);
|
|
|
|
if (empty($users)) {
|
|
return $this->getSyncEmptyResonse();
|
|
} else {
|
|
return [
|
|
'db_users' => $vistitors,
|
|
'chimp_response' => $this->subscribe($this->id_list, $users),
|
|
];
|
|
}
|
|
}
|
|
|
|
public function getShopConfig()
|
|
{
|
|
$config = [];
|
|
|
|
$id_lang_default = pqnp_config('PS_LANG_DEFAULT');
|
|
$config['id_lang_default'] = $id_lang_default;
|
|
$config['locale_country'] = pqnp_config('PS_LOCALE_COUNTRY');
|
|
$config['id_shop_default'] = pqnp_config('PS_SHOP_DEFAULT');
|
|
|
|
$groups = Group::getGroups($id_lang_default);
|
|
$config['groups'] = $groups;
|
|
$config['groups_name'] = self::grep($groups, 'name');
|
|
|
|
$shops = Shop::getShops(false);
|
|
$config['shops'] = $shops;
|
|
$config['shops_name'] = self::grep($shops, 'name');
|
|
$config['default_shop_name'] = pqnp_config('PS_SHOP_NAME');
|
|
|
|
$default_language = Language::getLanguage($id_lang_default);
|
|
$config['default_language'] = $default_language;
|
|
$config['default_language_name'] = $default_language['name'];
|
|
|
|
$languages = Language::getLanguages(false);
|
|
$config['languages'] = $languages;
|
|
$config['languages_name'] = self::grep($languages, 'name');
|
|
|
|
return $config;
|
|
}
|
|
|
|
private function getGroupingById($id, $groupings)
|
|
{
|
|
foreach ($groupings as $group) {
|
|
if ($group['id'] == $id) {
|
|
return $group;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private function deleteGroups($id_list, $id_grouping, &$groups_chimp)
|
|
{
|
|
$errors = [];
|
|
foreach ($groups_chimp as $key => $group) {
|
|
$response = $this->listDeleteGroup($id_list, $group['name'], $id_grouping);
|
|
if (!$response) {
|
|
$errors[self::ERROR_DELITING_GROUP] = $this->getErrors(true);
|
|
} else {
|
|
unset($groups_chimp[$key]);
|
|
}
|
|
}
|
|
|
|
return $errors;
|
|
}
|
|
|
|
private function createGroups($id_list, $id_grouping, &$groups_shop)
|
|
{
|
|
$errors = [];
|
|
foreach ($groups_shop as $key => $group) {
|
|
$response = $this->listAddGroup($id_list, $group['name'], $id_grouping);
|
|
if (!$response) {
|
|
$errors[self::ERROR_CREATE_GROUP] = $this->getErrors(true);
|
|
} else {
|
|
unset($groups_shop[$key]);
|
|
}
|
|
}
|
|
|
|
return $errors;
|
|
}
|
|
|
|
private function writeGroupsConfig($id_list, $id_grouping)
|
|
{
|
|
$config = [];
|
|
$interest = $this->listGroupGetInterest($id_list, $id_grouping);
|
|
$shop_config = $this->getShopConfig();
|
|
|
|
$groupingIds = [];
|
|
foreach ($interest[$id_grouping] as $group) {
|
|
foreach ($shop_config['groups'] as $shopGroup) {
|
|
if ($shopGroup['name'] === $group['name']) {
|
|
$groupingIds[$shopGroup['id_group']] = $group['id'];
|
|
}
|
|
}
|
|
}
|
|
|
|
pqnp_config('CHIMP.CUSTOMERS_GROUP_IDS', $groupingIds);
|
|
|
|
return $config;
|
|
}
|
|
|
|
public function checkChimpConfig()
|
|
{
|
|
$errors = [];
|
|
$shop_config = $this->getShopConfig();
|
|
|
|
// the id_list is the same with the ID_LIST fom configuration
|
|
$id_list = $this->id_list;
|
|
$list = $this->getListById($id_list);
|
|
if (!$list) {
|
|
$errors[self::ERROR_NO_LIST] = $this->getErrors(true);
|
|
} else {
|
|
$interest = $this->listGroupGetInterest($id_list, $this->id_grouping);
|
|
|
|
if (!$interest) {
|
|
$errors[self::ERROR_NO_GROUPING] = $this->getErrors(true);
|
|
} else {
|
|
// the id_grouping is the same with the ID_GROUPING fom configuration
|
|
$id_grouping = $this->id_grouping;
|
|
|
|
// $customers_group = $this->getGroupingById($id_grouping, $interest);
|
|
|
|
if (!array_key_exists($id_grouping, $interest)) {
|
|
$errors[self::ERROR_NO_CUSTOMERS_GROUP] = ['The grouping Customers Group is not find with the id '.$id_grouping.'.'];
|
|
} else {
|
|
// TODO: this is disabled for the moment
|
|
return $errors;
|
|
$groups_chimp = [];
|
|
|
|
$groups_shop = $shop_config['groups'];
|
|
|
|
$customers_group_ids = pqnp_config('CHIMP.CUSTOMERS_GROUP_IDS');
|
|
|
|
$groups_chimp_ids = [];
|
|
foreach ($interest[$id_grouping] as $key => $group) {
|
|
$groups_chimp_ids[$key] = $group['id'];
|
|
}
|
|
|
|
$groups_shop_ids = [];
|
|
foreach ($groups_shop as $key => $group) {
|
|
$groups_shop_ids[$key] = $group['id_group'];
|
|
}
|
|
|
|
foreach ($customers_group_ids as $group_shop_id => $group_chimp_id) {
|
|
$search_shop_key = array_search($group_shop_id, $groups_shop_ids);
|
|
$search_chimp_key = array_search($group_chimp_id, $groups_chimp_ids);
|
|
|
|
if (self::searchFind($search_shop_key) && self::searchFind($search_chimp_key)) {
|
|
$item_shop = $groups_shop[$search_shop_key];
|
|
|
|
if (isset($groups_chimp[$search_chimp_key])) {
|
|
$item_chimp = $groups_chimp[$search_chimp_key];
|
|
|
|
if ($item_shop['name'] != $item_chimp['name']) {
|
|
$response = $this->listUpdateGroup($id_list, $item_chimp['name'], $item_shop['name']);
|
|
if (!$response) {
|
|
$errors[self::ERROR_CHIMP_UPDATE_NAME] = $this->getErrors(true);
|
|
}
|
|
}
|
|
unset($groups_chimp[$search_chimp_key]);
|
|
}
|
|
|
|
unset($groups_shop[$search_shop_key]);
|
|
} else {
|
|
// not necessary
|
|
unset($customers_group_ids[$group_shop_id]);
|
|
}
|
|
}
|
|
|
|
// remove chimp unused groups
|
|
$response = $this->deleteGroups($id_list, $id_grouping, $groups_chimp);
|
|
if (!empty($response)) {
|
|
self::arrayMerge($errors, $response);
|
|
}
|
|
|
|
// add chimp groups
|
|
$response = $this->createGroups($id_list, $id_grouping, $groups_shop);
|
|
if (!empty($response)) {
|
|
self::arrayMerge($errors, $response);
|
|
}
|
|
|
|
$this->writeGroupsConfig($id_list, $id_grouping);
|
|
}
|
|
}
|
|
}
|
|
|
|
return $errors;
|
|
}
|
|
|
|
public function syncCheck()
|
|
{
|
|
$errors = [];
|
|
$codes = [];
|
|
$response_errors = $this->checkChimpConfig();
|
|
$shop_config = $this->getShopConfig();
|
|
|
|
if (!empty($response_errors)) {
|
|
$codes = array_keys($response_errors);
|
|
|
|
if (in_array(self::ERROR_NO_LIST, $codes)) {
|
|
$errors[] = 'The chimp list do not exists.';
|
|
}
|
|
|
|
if (in_array(self::ERROR_NO_CUSTOMERS_GROUP, $codes) || in_array(self::ERROR_NO_GROUPING, $codes)) {
|
|
if (!$this->installGrouping(self::GROUPINGS_NAME)) {
|
|
array_merge($errors, $this->errors);
|
|
}
|
|
}
|
|
|
|
if (in_array(self::ERROR_CHIMP_UPDATE_NAME, $codes)) {
|
|
$errors[] = 'The the name of the group cannot be updated.';
|
|
}
|
|
}
|
|
|
|
if (!in_array(self::ERROR_NO_LIST, $codes)) {
|
|
$list = $this->listGetVars($this->id_list);
|
|
|
|
if (!$list) {
|
|
$this->mergeErrors($errors);
|
|
} else {
|
|
$db_fields = pqnp_config('CHIMP.FIELDS');
|
|
$db_fields_name = self::grep($db_fields, 'tag');
|
|
|
|
$fields = $list['merge_vars'];
|
|
$fields_tag = [];
|
|
|
|
foreach ($fields as $field) {
|
|
if ('EMAIL' != $field['tag']) {
|
|
$fields_tag[] = $field['tag'];
|
|
}
|
|
}
|
|
|
|
foreach ($db_fields_name as $field) {
|
|
if ('EMAIL' != $field && !in_array($field, $fields_tag)) {
|
|
if (!$this->installFields()) {
|
|
array_merge($errors, $this->errors);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
$shop_tag = null;
|
|
foreach ($fields as $field) {
|
|
if ('SHOP' == $field['tag']) {
|
|
$shop_tag = $field;
|
|
break;
|
|
}
|
|
}
|
|
|
|
$db_shops = $shop_config['shops'];
|
|
$db_shops_name = self::grep($db_shops, 'name');
|
|
if (isset($shop_tag)) {
|
|
$shop_choices = $shop_tag['choices'];
|
|
$shop_add = array_diff($db_shops_name, $shop_choices);
|
|
$shop_remove = array_diff($shop_choices, $db_shops_name);
|
|
|
|
if (!empty($shop_add) || !empty($shop_remove)) {
|
|
$response = $this->listUpdateVar($this->id_list, 'SHOP', 'SHOP', [
|
|
'options' => [
|
|
'choices' => $db_shops_name,
|
|
],
|
|
]);
|
|
|
|
if (!$response) {
|
|
array_merge($errors, $this->errors);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (empty($errors)) {
|
|
return true;
|
|
} else {
|
|
$this->errors = $errors;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public function syncListsBack($start = 0, $limit = 25)
|
|
{
|
|
try {
|
|
$result = $this->syncListsBackStep($start, $limit);
|
|
$this->response->setArray($result);
|
|
} catch (Exception $e) {
|
|
$this->response->addError($e->getMessage());
|
|
}
|
|
|
|
return $this->response->display();
|
|
}
|
|
|
|
public function syncListsBackStep($start = 0, $limit = 25)
|
|
{
|
|
$data = $this->getListMembers($this->id_list, $start, $limit);
|
|
|
|
if (!$data) {
|
|
$errors = $this->getErrors();
|
|
|
|
if (count($errors)) {
|
|
foreach ($errors as $value) {
|
|
throw new Exception($value['error']);
|
|
}
|
|
}
|
|
}
|
|
|
|
$list = $this->getListById($this->id_list);
|
|
$member_count = $list['stats']['member_count'];
|
|
|
|
$created = 0;
|
|
$updated = 0;
|
|
$errors = 0;
|
|
|
|
foreach ($data as $chimp_data) {
|
|
try {
|
|
$user = NewsletterProMailChimpUserImport::newInstance($chimp_data['email']);
|
|
$user->set($chimp_data);
|
|
|
|
if ($user->userExists()) {
|
|
if ($user->save()) {
|
|
++$updated;
|
|
} else {
|
|
++$errors;
|
|
}
|
|
} else {
|
|
if ($user->save()) {
|
|
++$created;
|
|
} else {
|
|
++$errors;
|
|
}
|
|
}
|
|
} catch (Exception $e) {
|
|
NewsletterProLog::writeStrip($e->getMessage(), NewsletterProLog::ERROR_FILE);
|
|
++$errors;
|
|
}
|
|
}
|
|
|
|
$success = $created + $updated;
|
|
$total = $success + $errors;
|
|
|
|
return [
|
|
'total' => $total,
|
|
'success' => $success,
|
|
'created' => $created,
|
|
'updated' => $updated,
|
|
'errors_count' => $errors,
|
|
'member_count' => $member_count,
|
|
'start' => $start,
|
|
'limit' => $limit,
|
|
];
|
|
}
|
|
|
|
public function syncLists($from, $to = null)
|
|
{
|
|
$errors = [];
|
|
$couts = [];
|
|
|
|
if (!$this->syncCheck()) {
|
|
$errors = $this->errors;
|
|
} else {
|
|
if (pqnp_config('CHIMP.ADDED_CHECKBOX')) {
|
|
$response = $this->syncAddedByDate($from, $to);
|
|
$response = $response['chimp_response'];
|
|
if (!$response) {
|
|
$this->mergeErrors($errors);
|
|
} else {
|
|
$couts['added'] = [
|
|
'adds' => count($response['adds']),
|
|
'updates' => count($response['updates']),
|
|
'errors' => count($response['errors']),
|
|
];
|
|
}
|
|
} else {
|
|
$errors[] = $this->l('The "added" list is not activated for the synchronization. You need to check it from the module.');
|
|
}
|
|
|
|
if (pqnp_config('CHIMP.VISITORS_CHECKBOX')) {
|
|
$response = ((bool) pqnp_config('SUBSCRIPTION_ACTIVE') ? $this->syncVisitorsNPByDate($from, $to) : $this->syncVisitorsByDate($from, $to));
|
|
|
|
$response = $response['chimp_response'];
|
|
if (!$response) {
|
|
$this->mergeErrors($errors);
|
|
} else {
|
|
$couts['visitors'] = [
|
|
'adds' => count($response['adds']),
|
|
'updates' => count($response['updates']),
|
|
'errors' => count($response['errors']),
|
|
];
|
|
}
|
|
} else {
|
|
$errors[] = $this->l('The "visitors" list is not activated for the synchronization. You need to check it from the module.');
|
|
}
|
|
|
|
if (pqnp_config('CHIMP.CUSTOMERS_CHECKBOX')) {
|
|
$response = $this->syncCustomersByDate($from, $to);
|
|
$response = $response['chimp_response'];
|
|
if (!$response) {
|
|
$this->mergeErrors($errors);
|
|
} else {
|
|
$couts['customers'] = [
|
|
'adds' => count($response['adds']),
|
|
'updates' => count($response['updates']),
|
|
'errors' => count($response['errors']),
|
|
];
|
|
}
|
|
} else {
|
|
$errors[] = $this->l('The "customers" list is not activated for the synchronization. You need to check it from the module.');
|
|
}
|
|
|
|
if (pqnp_config('CHIMP.ORDERS_CHECKBOX')) {
|
|
$orders_date = NewsletterProConfig::get('CHIMP_LAST_DATE_SYNC_ORDERS');
|
|
|
|
$response = $this->syncOrdersByDate($orders_date);
|
|
|
|
$chimp_response = $response['chimp_response'];
|
|
$db_users = $response['db_users'];
|
|
|
|
$db_last_date_add = false;
|
|
if (!empty($db_users)) {
|
|
$db_date_add = self::grep($db_users, 'date_add');
|
|
|
|
$db_date_add_time = [];
|
|
foreach ($db_date_add as $date) {
|
|
$db_date_add_time[$date] = strtotime($date);
|
|
}
|
|
|
|
if (!empty($db_date_add_time)) {
|
|
$db_last_date_add = date('Y-m-d H:i:s', max($db_date_add_time));
|
|
}
|
|
}
|
|
|
|
$adds = 0;
|
|
$errors_cout = 0;
|
|
|
|
if ($db_last_date_add) {
|
|
foreach ($chimp_response as $value) {
|
|
if (isset($value['complete']) && $value['complete']) {
|
|
++$adds;
|
|
} else {
|
|
++$errors_cout;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!$response) {
|
|
$this->mergeErrors($errors);
|
|
} else {
|
|
$couts['orders'] = [
|
|
'adds' => $adds,
|
|
'updates' => 0,
|
|
'errors' => $errors_cout,
|
|
];
|
|
|
|
if ($db_last_date_add) {
|
|
NewsletterProConfig::save('CHIMP_LAST_DATE_SYNC_ORDERS', $db_last_date_add);
|
|
}
|
|
}
|
|
} else {
|
|
$errors[] = $this->l('The "orders" are not activated for the synchronization. You need to check it from the module.');
|
|
}
|
|
}
|
|
|
|
return [
|
|
'errors' => $errors,
|
|
'couts' => $couts,
|
|
];
|
|
}
|
|
|
|
public function installFields()
|
|
{
|
|
$errors = [];
|
|
$save_tags_response = [];
|
|
$id_list = $this->id_list;
|
|
if ($list_vars = $this->listGetVars($id_list)) {
|
|
$mcv = new NewsletterProMailChimpFields($list_vars['merge_vars']);
|
|
|
|
$save_tags = $mcv->getSyncVars();
|
|
|
|
foreach ($save_tags as $type => $tag) {
|
|
if ('add' == $type) {
|
|
foreach ($tag as $tag_name => $tag_value) {
|
|
$response = $this->listAddVar($id_list, $tag_name, $tag_value['name'], [
|
|
'options' => $tag_value['options'],
|
|
]);
|
|
|
|
if (!$response) {
|
|
$this->mergeErrors($errors);
|
|
} else {
|
|
$save_tags_response[] = $response;
|
|
}
|
|
}
|
|
} elseif ('update' == $type) {
|
|
foreach ($tag as $tag_name => $tag_value) {
|
|
unset($tag_value['options']['field_type']);
|
|
|
|
$response = $this->listUpdateVar($id_list, $tag_name, $tag_value['name'], [
|
|
'options' => $tag_value['options'],
|
|
]);
|
|
|
|
if (!$response) {
|
|
$this->mergeErrors($errors);
|
|
} else {
|
|
$save_tags_response[] = $response;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
$this->mergeErrors($errors);
|
|
}
|
|
|
|
$fields = [];
|
|
|
|
foreach ($save_tags_response as $value) {
|
|
$fields[] = [
|
|
'name' => $value['name'],
|
|
'tag' => $value['tag'],
|
|
];
|
|
}
|
|
|
|
pqnp_config('CHIMP.FIELDS', $fields);
|
|
|
|
if (empty($errors)) {
|
|
return $save_tags_response;
|
|
} else {
|
|
$this->errors = $errors;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public function pingChimp()
|
|
{
|
|
$errors = [];
|
|
$response = [
|
|
'status' => false,
|
|
'errors' => &$errors,
|
|
'message' => '',
|
|
];
|
|
|
|
if ($ping = $this->ping()) {
|
|
$response['message'] = $ping;
|
|
$response['status'] = true;
|
|
} else {
|
|
$this->mergeErrors($errors);
|
|
}
|
|
|
|
if (empty($errors)) {
|
|
$response['status'] = true;
|
|
}
|
|
|
|
return Tools::jsonEncode($response);
|
|
}
|
|
|
|
public function installChimp($api_key, $list_id)
|
|
{
|
|
$errors = [];
|
|
$response = [
|
|
'status' => false,
|
|
'errors' => &$errors,
|
|
'message' => '',
|
|
];
|
|
|
|
try {
|
|
if (!extension_loaded('curl')) {
|
|
throw new Exception(sprintf($this->module->l('The availability of php %s library is not available on your server. You can talk with the hosting provider to enable it.'), 'curl'));
|
|
}
|
|
|
|
if (empty($api_key)) {
|
|
$errors[] = $this->l('The Api Key field is empty.');
|
|
}
|
|
if (empty($list_id)) {
|
|
$errors[] = $this->l('The List ID field is empty.');
|
|
}
|
|
|
|
if (empty($errors)) {
|
|
if ($this->installConfiguration($api_key, $list_id)) {
|
|
if ($this->ping()) {
|
|
if ($this->getListById($list_id) && $this->install()) {
|
|
pqnp_config('CHIMP.INSTALLED', true);
|
|
|
|
$response['message'] = $this->l('Mail Chimp was successfully installed!');
|
|
$response['status'] = true;
|
|
} else {
|
|
$this->mergeErrors($errors);
|
|
}
|
|
} else {
|
|
$errors[] = $this->l('Invalid MailChimp Api Key: ').$api_key;
|
|
}
|
|
} else {
|
|
$errors[] = $this->l('The Mail Chimp database configuration cannot be installed.');
|
|
}
|
|
}
|
|
} catch (Exception $e) {
|
|
$errors[] = $e->getMessage();
|
|
}
|
|
|
|
return Tools::jsonEncode($response);
|
|
}
|
|
|
|
public function uninstallConfiguration()
|
|
{
|
|
pqnp_config('CHIMP.INSTALLED', false);
|
|
|
|
return true;
|
|
}
|
|
|
|
public function uninstallChimp()
|
|
{
|
|
$errors = [];
|
|
$response = [
|
|
'status' => false,
|
|
'errors' => &$errors,
|
|
'message' => '',
|
|
];
|
|
|
|
if ($this->uninstallConfiguration()) {
|
|
$response['message'] = $this->l('Mail Chimp was successfully uninstalled!');
|
|
$response['status'] = true;
|
|
} else {
|
|
$errors[] = $this->l('Mail Chimp cannot be uninstalled.');
|
|
}
|
|
|
|
return Tools::jsonEncode($response);
|
|
}
|
|
|
|
public function updateSyncCheckbox($name, $value)
|
|
{
|
|
$errors = [];
|
|
$response = ['status' => false, 'errors' => &$errors];
|
|
pqnp_config("CHIMP.{$name}", $value);
|
|
$response['status'] = true;
|
|
|
|
return Tools::jsonEncode($response);
|
|
}
|
|
|
|
public function l($value)
|
|
{
|
|
return $this->module->l($value);
|
|
}
|
|
|
|
public function setSyncLists($data)
|
|
{
|
|
$errors = [];
|
|
$response = ['status' => false, 'errors' => &$errors];
|
|
$chimp_sync = [];
|
|
|
|
if (!$this->syncCheck()) {
|
|
$errors = $this->errors;
|
|
} else {
|
|
if ($data['ADDED_CHECKBOX']) {
|
|
$chimp_sync['ADDED_CHECKBOX'] = [
|
|
'id' => 1,
|
|
'total' => $this->countAdded(),
|
|
'updates' => 0,
|
|
'created' => 0,
|
|
'errors' => 0,
|
|
'errors_message' => [],
|
|
'in_progress' => false,
|
|
'done' => false,
|
|
];
|
|
}
|
|
|
|
$visitors_count = ((bool) pqnp_config('SUBSCRIPTION_ACTIVE') ? $this->countVisitorsNP() : $this->countVisitors());
|
|
|
|
if ($data['VISITORS_CHECKBOX']) {
|
|
$chimp_sync['VISITORS_CHECKBOX'] = [
|
|
'id' => 1,
|
|
'total' => $visitors_count,
|
|
'updates' => 0,
|
|
'created' => 0,
|
|
'errors' => 0,
|
|
'errors_message' => [],
|
|
'in_progress' => false,
|
|
'done' => false,
|
|
];
|
|
}
|
|
|
|
if ($data['CUSTOMERS_CHECKBOX']) {
|
|
$chimp_sync['CUSTOMERS_CHECKBOX'] = [
|
|
'id' => 1,
|
|
'total' => $this->countCustomers(),
|
|
'updates' => 0,
|
|
'created' => 0,
|
|
'errors' => 0,
|
|
'errors_message' => [],
|
|
'in_progress' => false,
|
|
'done' => false,
|
|
];
|
|
}
|
|
|
|
if ($data['ORDERS_CHECKBOX']) {
|
|
$chimp_sync['ORDERS_CHECKBOX'] = [
|
|
'id' => 1,
|
|
'total' => $this->countOrders(NewsletterProConfig::get('CHIMP_LAST_DATE_SYNC_ORDERS')),
|
|
'date_add' => NewsletterProConfig::get('CHIMP_LAST_DATE_SYNC_ORDERS'),
|
|
'updates' => 0,
|
|
'created' => 0,
|
|
'errors' => 0,
|
|
'errors_message' => [],
|
|
'in_progress' => false,
|
|
'done' => false,
|
|
];
|
|
}
|
|
|
|
// set ajx loader
|
|
if (isset($chimp_sync['ADDED_CHECKBOX'])) {
|
|
$chimp_sync['ADDED_CHECKBOX']['in_progress'] = true;
|
|
} elseif (isset($chimp_sync['VISITORS_CHECKBOX'])) {
|
|
$chimp_sync['VISITORS_CHECKBOX']['in_progress'] = true;
|
|
} elseif (isset($chimp_sync['CUSTOMERS_CHECKBOX'])) {
|
|
$chimp_sync['CUSTOMERS_CHECKBOX']['in_progress'] = true;
|
|
} elseif (isset($chimp_sync['ORDERS_CHECKBOX'])) {
|
|
$chimp_sync['ORDERS_CHECKBOX']['in_progress'] = true;
|
|
}
|
|
|
|
$chimp_sync['ERRORS'] = [];
|
|
|
|
if (NewsletterProConfig::saveArray('CHIMP_SYNC', $chimp_sync)) {
|
|
$response['status'] = true;
|
|
} else {
|
|
$errors[] = $this->l('Sync list not started. The sync list configuration cannot be saved.');
|
|
}
|
|
}
|
|
|
|
return Tools::jsonEncode($response);
|
|
}
|
|
|
|
public function deleteChimpOrders()
|
|
{
|
|
$response = NewsletterProAjaxResponse::newInstance([
|
|
'msg' => '',
|
|
'date_add' => '0000-00-00 00:00:00',
|
|
]);
|
|
|
|
$chimp_orders = $this->getAllOrders(0, 500);
|
|
|
|
$msg_set = false;
|
|
$success = 0;
|
|
if (!empty($chimp_orders['data'])) {
|
|
foreach ($chimp_orders['data'] as $order) {
|
|
if ($this->orderDelete($order['store_id'], $order['order_id'])) {
|
|
++$success;
|
|
} else {
|
|
$response->mergeErrors($this->getErrors(true, true));
|
|
}
|
|
}
|
|
} else {
|
|
$errors = $this->getErrors(true, true);
|
|
if (!empty($errors)) {
|
|
$response->mergeErrors($errors);
|
|
} else {
|
|
$msg_set = true;
|
|
$response->set('msg', $this->l('There no MailChimp orders to delete.'));
|
|
}
|
|
}
|
|
|
|
if (!$msg_set) {
|
|
$response->set('msg', sprintf($this->l('(%s) was deleted successfully, (%s) errors'), $success, count($response->getErrors())));
|
|
}
|
|
|
|
$reset_date = '0000-00-00 00:00:00';
|
|
|
|
$response->set('date_add', $reset_date);
|
|
NewsletterProConfig::save('CHIMP_LAST_DATE_SYNC_ORDERS', $reset_date);
|
|
|
|
return $response->display();
|
|
}
|
|
|
|
public function resetSyncOrderDate()
|
|
{
|
|
$reset_date = '0000-00-00 00:00:00';
|
|
$response = NewsletterProAjaxResponse::newInstance([
|
|
'date_add' => $reset_date,
|
|
]);
|
|
|
|
$response->set('date_add', $reset_date);
|
|
if (!NewsletterProConfig::save('CHIMP_LAST_DATE_SYNC_ORDERS', $reset_date)) {
|
|
$response->addError($this->l('An error occurred.'));
|
|
}
|
|
|
|
return $response->display();
|
|
}
|
|
|
|
public function getAllOrders($start = 0, $limit = 500, $orders = null)
|
|
{
|
|
if (!isset($orders)) {
|
|
$orders = [
|
|
'total' => 0,
|
|
'total_find' => 0,
|
|
'data' => [],
|
|
];
|
|
}
|
|
|
|
$chimp_orders = $this->getOrders(null, $start, $limit);
|
|
if (!$chimp_orders) {
|
|
return $orders;
|
|
} else {
|
|
$orders['total'] = $chimp_orders['total'];
|
|
$orders['total_find'] += count($chimp_orders['data']);
|
|
$orders['data'] = array_merge($orders['data'], $chimp_orders['data']);
|
|
|
|
if ($orders['total'] > $orders['total_find'] && count($chimp_orders['data']) > 0) {
|
|
++$start;
|
|
|
|
return $this->getAllOrders($start, $limit, $orders);
|
|
}
|
|
}
|
|
|
|
return $orders;
|
|
}
|
|
|
|
public function getSyncListName($chimp_sync)
|
|
{
|
|
if (is_array($chimp_sync)) {
|
|
foreach ($chimp_sync as $name => $list) {
|
|
if (isset($list['done']) && false == $list['done']) {
|
|
return $name;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public function processSync()
|
|
{
|
|
$chimp_sync = NewsletterProConfig::getArray('CHIMP_SYNC');
|
|
$name = $this->getSyncListName($chimp_sync);
|
|
|
|
if ($name) {
|
|
$list = &$chimp_sync[$name];
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
switch ($name) {
|
|
case 'ADDED_CHECKBOX':
|
|
$response = $this->syncAdded($list['id'], $this->sync_step);
|
|
break;
|
|
|
|
case 'VISITORS_CHECKBOX':
|
|
if ((bool) pqnp_config('SUBSCRIPTION_ACTIVE')) {
|
|
$response = $this->syncVisitorsNP($list['id'], $this->sync_step);
|
|
} else {
|
|
$response = $this->syncVisitors($list['id'], $this->sync_step);
|
|
}
|
|
break;
|
|
|
|
case 'CUSTOMERS_CHECKBOX':
|
|
$response = $this->syncCustomers($list['id'], $this->sync_step);
|
|
break;
|
|
|
|
case 'ORDERS_CHECKBOX':
|
|
//this is the usual function syncOrders
|
|
$response = $this->syncOrdersByDate($list['date_add']);
|
|
break;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
switch ($name) {
|
|
case 'ADDED_CHECKBOX':
|
|
case 'VISITORS_CHECKBOX':
|
|
case 'CUSTOMERS_CHECKBOX':
|
|
if ($response['chimp_response']) {
|
|
$db_last_id = 0;
|
|
if (!empty($response['db_users'])) {
|
|
$db_ids = self::grep($response['db_users'], 'id');
|
|
if (!empty($db_ids)) {
|
|
$db_last_id = max($db_ids);
|
|
} else {
|
|
throw new Exception('Invalid db_users id for the list "'.$name.'"');
|
|
}
|
|
}
|
|
|
|
if (0 == $db_last_id) {
|
|
$list['in_progress'] = false;
|
|
$list['done'] = true;
|
|
} else {
|
|
$chimp_response = $response['chimp_response'];
|
|
|
|
$list['id'] = $db_last_id + 1;
|
|
$list['created'] += $chimp_response->getContent('total_created');
|
|
$list['updates'] += $chimp_response->getContent('total_updated');
|
|
$list['errors'] += $chimp_response->getContent('error_count');
|
|
$list['errors_message'] = $chimp_response->getContent('errors');
|
|
$list['in_progress'] = true;
|
|
$list['done'] = false;
|
|
}
|
|
} elseif (empty($response['db_users'])) {
|
|
$list['in_progress'] = false;
|
|
$list['done'] = true;
|
|
} else {
|
|
$list['done'] = true;
|
|
$list['in_progress'] = false;
|
|
|
|
if (!isset($chimp_sync['ERRORS'])) {
|
|
$chimp_sync['ERRORS'] = [];
|
|
}
|
|
|
|
$chimp_sync['ERRORS'] = array_unique(array_merge($chimp_sync['ERRORS'], $this->getErrors(true, true)));
|
|
}
|
|
|
|
$chimp_sync['ERRORS_MESSAGE'] = $list['errors_message'];
|
|
|
|
break;
|
|
|
|
case 'ORDERS_CHECKBOX':
|
|
if ($response['chimp_response']) {
|
|
$db_last_id = 0;
|
|
$db_last_date_add = false;
|
|
|
|
if (!empty($response['db_users'])) {
|
|
$db_ids = self::grep($response['db_users'], 'id_order');
|
|
if (!empty($db_ids)) {
|
|
$db_last_id = max($db_ids);
|
|
} else {
|
|
throw new Exception('Invalid db_users id for the list "'.$name.'"');
|
|
}
|
|
|
|
$db_date_add = self::grep($response['db_users'], 'date_add');
|
|
|
|
$db_date_add_time = [];
|
|
foreach ($db_date_add as $date) {
|
|
$db_date_add_time[$date] = strtotime($date);
|
|
}
|
|
|
|
if (!empty($db_date_add_time)) {
|
|
$db_last_date_add = date('Y-m-d H:i:s', max($db_date_add_time));
|
|
}
|
|
}
|
|
|
|
if (!$db_last_date_add || 0 == $db_last_id) {
|
|
$list['in_progress'] = false;
|
|
$list['done'] = true;
|
|
} else {
|
|
$chimp_response = $response['chimp_response'];
|
|
|
|
foreach ($chimp_response as $value) {
|
|
if (isset($value['complete']) && $value['complete']) {
|
|
++$list['created'];
|
|
} else {
|
|
++$list['errors'];
|
|
}
|
|
}
|
|
|
|
$chimp_last_date_sync_orders = date('Y-m-d H:i:s', strtotime($db_last_date_add) + 1);
|
|
|
|
$list['id'] = $db_last_id + 1;
|
|
$list['date_add'] = $chimp_last_date_sync_orders;
|
|
$list['updates'] = 0;
|
|
$list['in_progress'] = true;
|
|
$list['done'] = false;
|
|
|
|
NewsletterProConfig::save('CHIMP_LAST_DATE_SYNC_ORDERS', $chimp_last_date_sync_orders);
|
|
}
|
|
} elseif (empty($response['db_users'])) {
|
|
$list['in_progress'] = false;
|
|
$list['done'] = true;
|
|
} else {
|
|
$list['done'] = true;
|
|
$list['in_progress'] = false;
|
|
|
|
if (!isset($chimp_sync['ERRORS'])) {
|
|
$chimp_sync['ERRORS'] = [];
|
|
}
|
|
|
|
$chimp_sync['ERRORS'] = array_unique(array_merge($chimp_sync['ERRORS'], $this->getErrors(true, true)));
|
|
}
|
|
|
|
break;
|
|
}
|
|
} catch (Exception $e) {
|
|
$list['done'] = true;
|
|
$list['in_progress'] = false;
|
|
|
|
$chimp_sync['ERRORS'][] = $e->getMessage();
|
|
}
|
|
|
|
NewsletterProConfig::saveArray('CHIMP_SYNC', $chimp_sync);
|
|
}
|
|
|
|
public function stopSync()
|
|
{
|
|
$errors = [];
|
|
$response = ['status' => false, 'errors' => &$errors];
|
|
|
|
if (NewsletterProConfig::saveArray('CHIMP_SYNC', [])) {
|
|
$response['status'] = true;
|
|
} else {
|
|
$errors[] = $this->l('The synchronization cannot be stopped.');
|
|
}
|
|
|
|
return Tools::jsonEncode($response);
|
|
}
|
|
|
|
public function startSyncLists()
|
|
{
|
|
@ini_set('max_execution_time', '2880');
|
|
|
|
if ($this->ping()) {
|
|
NewsletterProConfig::save('LAST_DATE_CHIMP_SYNC', date('Y-m-d H:i:s'));
|
|
}
|
|
|
|
$this->processSync();
|
|
// run in background
|
|
return Tools::jsonEncode(NewsletterProConfig::getArray('CHIMP_SYNC'));
|
|
}
|
|
|
|
public function getSyncListsStatus()
|
|
{
|
|
$response = [
|
|
'chimp_sync' => NewsletterProConfig::getArray('CHIMP_SYNC'),
|
|
];
|
|
|
|
return Tools::jsonEncode($response);
|
|
}
|
|
|
|
public function getAllTemplates()
|
|
{
|
|
$response = ['status' => false, 'errors' => [], 'templates' => []];
|
|
|
|
$templates = $this->getTemplates();
|
|
if (!$templates) {
|
|
$response['errors'] = $this->getErrors(true);
|
|
} else {
|
|
$response['status'] = true;
|
|
$response['templates'] = $templates;
|
|
}
|
|
|
|
return Tools::jsonEncode($response);
|
|
}
|
|
|
|
public function getTemplateSource($template_id, $type)
|
|
{
|
|
$response = ['status' => false, 'errors' => [], 'template' => ''];
|
|
|
|
$template = $this->getTemplateContent($template_id, $type);
|
|
|
|
if (!$template) {
|
|
$response['errors'] = $this->getErrors(true);
|
|
} else {
|
|
$response['status'] = true;
|
|
$response['template'] = $template['source'];
|
|
}
|
|
|
|
return Tools::jsonEncode($response);
|
|
}
|
|
|
|
public function importTemplate($name, $content, $override = false)
|
|
{
|
|
try {
|
|
$this->response->setArray([
|
|
'worning' => [],
|
|
'template_name' => '',
|
|
// 'template' => '',
|
|
]);
|
|
|
|
$name = NewsletterProTemplate::formatName($name);
|
|
|
|
if (($validate_error = $this->module->verifyName($name)) !== true) {
|
|
throw new Exception($validate_error);
|
|
}
|
|
|
|
$name = $name.'.html';
|
|
|
|
$template = NewsletterProTemplate::newString([$name, $content])->load();
|
|
|
|
$this->response->set('template_name', $template->name);
|
|
|
|
if ($override) {
|
|
$template->save();
|
|
} else {
|
|
if (NewsletterProTemplate::templateExists($name)) {
|
|
$this->response->set('worning', [
|
|
101 => sprintf($this->l('A file with the name "%s" already exists! Do you want to override the file?'), $name),
|
|
]);
|
|
} else {
|
|
$template->save();
|
|
}
|
|
}
|
|
} catch (Exception $e) {
|
|
$this->response->addError($e->getMessage());
|
|
}
|
|
|
|
return $this->response->display();
|
|
}
|
|
|
|
public function exportTemplate($name, $id_lang, $filename, $override = false)
|
|
{
|
|
$this->response->setArray([
|
|
'status' => false,
|
|
'name_exists' => false,
|
|
'message' => '',
|
|
]);
|
|
|
|
try {
|
|
$template = NewsletterProTemplate::newFile($filename, [null, NewsletterProTemplateUser::USER_TYPE_EMPLOYEE])->load($id_lang);
|
|
$content = $template->renderMailChimp(NewsletterProTemplateContent::CONTENT_HTML);
|
|
|
|
$all_templates = $this->getTemplates([
|
|
'user' => true,
|
|
'gallery' => false,
|
|
'base' => false,
|
|
], ['include_inactive' => true]);
|
|
|
|
if (!$all_templates) {
|
|
$errors = $this->getErrors(true);
|
|
|
|
foreach ($errors as $error) {
|
|
throw new Exception($error);
|
|
}
|
|
}
|
|
|
|
$templates = $all_templates['user'];
|
|
$templates_name = [];
|
|
foreach ($templates as $key => $value) {
|
|
$templates_name[$key] = $value['name'];
|
|
}
|
|
|
|
$key_search = array_search($name, $templates_name);
|
|
|
|
if (false !== $key_search) {
|
|
$find_template = $templates[$key_search];
|
|
|
|
if (!$override) {
|
|
$this->response->set('name_exists', true);
|
|
$this->response->set('message', sprintf($this->l('A template with the name "%s" already exists. Do you want to override it?'), $name));
|
|
} else {
|
|
$update_response = $this->templateUpdate($find_template['id'], $name, $content);
|
|
if (!$update_response) {
|
|
$req_errors = $this->getErrors(true);
|
|
|
|
foreach ($req_errors as $error) {
|
|
throw new Exception($error);
|
|
}
|
|
}
|
|
|
|
if (!(int) $find_template['active']) {
|
|
$undel_response = $this->templateUndel($find_template['id']);
|
|
|
|
if (!$undel_response) {
|
|
$req_errors = $this->getErrors(true);
|
|
|
|
foreach ($req_errors as $error) {
|
|
throw new Exception($error);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
$add_response = $this->templateAdd($name, $content);
|
|
|
|
if (!$add_response) {
|
|
$req_errors = $this->getErrors(true);
|
|
|
|
foreach ($req_errors as $error) {
|
|
throw new Exception($error);
|
|
}
|
|
}
|
|
}
|
|
} catch (Exception $e) {
|
|
$this->response->addError($e->getMessage());
|
|
}
|
|
|
|
return $this->response->display();
|
|
}
|
|
}
|