<?php
|
namespace JVBase\integrations;
|
|
use Exception;
|
use JVBase\meta\Meta;
|
use JVBase\meta\Sanitizer;
|
use JVBase\registrar\Registrar;
|
use WP_Error;
|
use WP_Post;
|
use WP_Term;
|
use WP_User;
|
|
if (!defined('ABSPATH')) {
|
exit;
|
}
|
|
trait SyncTo {
|
use SyncHelpers, UserConnection;
|
/**
|
* Must be defined according to how each service needs it to be
|
* @param int $itemID
|
* @param string $type
|
* @return array
|
* @throws Exception
|
*/
|
abstract protected function formatForService(int $itemID, string $type = 'post'):array;
|
|
/**
|
* Defaults to an array of formatted items. Can be overridden in child classes
|
* @param array $itemIDs
|
* @param string $type
|
* @return array
|
*/
|
protected function formatItems(array $itemIDs, string $type):array
|
{
|
$items = [];
|
foreach ($itemIDs as $ID) {
|
try {
|
$items[] = $this->formatForService($ID, $type);
|
} catch (Exception $e){
|
$this->logError('formatItems', 'Could not format Item for service',[
|
'itemID' => $ID,
|
'type' => $type,
|
'message' => $e->getMessage(),
|
]);
|
}
|
}
|
return $items;
|
}
|
/***************************************************************
|
* Item creation
|
***************************************************************/
|
public function createBatchToService($data):array
|
{
|
$type = $data['type']??'post';
|
|
//Check if any of the submitted ids are already created
|
$created = array_filter($data['items'],
|
function($ID) use ($type) {
|
return !empty($this->getServiceItemID($ID, $type));
|
});
|
|
$updated = [];
|
if (!empty($created)) {
|
$updateData = $data;
|
$updateData['items'] = $created;
|
$updated = $this->updateBatchToService($data);
|
|
//remove any updated items from the original items to process
|
$data['items'] = array_filter($data['items'], function ($ID) use ($created) {
|
return !in_array($ID, $created);
|
});
|
}
|
|
$items = $this->formatItems($data['items'], $type);
|
if (empty($items)) {
|
return $this->noCreatedItems($updated);
|
}
|
|
if ($this->hasBatchCreate) {
|
$response = $this->sendBatchCreate($items);
|
if (!is_wp_error($response)) {
|
$result = $this->processBatchCreateResponse($data, $response);
|
} else {
|
$this->logError('createBatchToService','Batch create failed',[
|
'method' => 'createBatchToService',
|
'item_ids' => $data['items'],
|
'error' => $response
|
]);
|
$this->updateItemStatus($data['items'], 'error');
|
|
$result = [
|
'outcome' => 'failed_permanent',
|
'result' => 'Could not update items'
|
];
|
}
|
} else {
|
$success = $errors = [];
|
foreach ($items as $item) {
|
$itemResult = $this->createOne($item);
|
if (!is_wp_error($itemResult)) {
|
$success[] = $itemResult;
|
} else {
|
$errors[] = $itemResult;
|
}
|
}
|
$result = [
|
'outcome' => empty($errors) ? 'success' : (empty($success) ? 'failed' : 'partial'),
|
'result' => [
|
'success' => $success,
|
'errors' => $errors
|
]
|
];
|
}
|
|
return array_merge($result, $updated);
|
}
|
|
/**
|
* To be implemented by integration extension. Updates a single item
|
* @param array $item
|
* @return array|WP_Error
|
*/
|
protected function createOne(array $item):array|WP_Error
|
{
|
return new WP_Error('invalid', 'Integration '.$this->service_name.' must implement its own createOne');
|
}
|
|
/**
|
* Overridden by child classes
|
* @param array $items
|
* @return array|WP_Error
|
*/
|
protected function sendBatchCreate(array $items):array|WP_Error
|
{
|
return new WP_Error('invalid', 'Integration '.$this->service_name.' must implement its own sendBatchCreate');
|
}
|
|
/**
|
* To be implemented by extensions
|
* @param array $data
|
* @param array $response
|
* @return array
|
*/
|
protected function processBatchCreateResponse(array $data, array $response):array
|
{
|
return [
|
'outcome' => 'failed',
|
'result' => [
|
'message' => $this->service_name.' should implement processBatchCreateResponse.'
|
]
|
];
|
}
|
|
/*****************************************************************
|
* ITEM UPDATING
|
*****************************************************************/
|
public function updateBatchToService(array $data):array
|
{
|
$type = $data['type']??'post';
|
|
$newlyCreated = [];
|
if (!$this->canCreateOnUpdate) {
|
$created = array_filter($data['items'], function($ID) use ($type) {
|
return !empty($this->getServiceItemID($ID, $type));
|
});
|
|
//Test to see if we have any that haven't been created yet.
|
//For some services, items may have to be created before they can be updated
|
if (count($created) !== count($data['items'])) {
|
$notCreated = array_filter($data['items'], function($ID) use ($type) {
|
return empty($this->getServiceItemID($ID, $type));
|
});
|
$newData = $data;
|
$newData['items'] = $notCreated;
|
$newlyCreated = $this->createBatchToService($newData);
|
}
|
|
// If we don't have any that are created, just send the noUpdatedItems response, with any newly created items added
|
if (empty($created)) {
|
return $this->noUpdatedItems($newlyCreated);
|
}
|
$data['items'] = $created;
|
}
|
|
|
$items = $this->formatItems($data['items'], $type);
|
|
if (empty($items)) {
|
return $this->noUpdatedItems($newlyCreated);
|
}
|
|
if ($this->hasBatchUpdate) {
|
$response = $this->sendBatchUpdate($items);
|
if (!is_wp_error($response)) {
|
$result = $this->processBatchUpdateResponse($data, $response);
|
} else {
|
$this->logError('updateBatchToService','Batch update failed',[
|
'method' => 'updateBatchToService',
|
'item_ids' => $data['items'],
|
'error' => $response
|
]);
|
$this->updateItemStatus($data['items'], 'error');
|
|
$result = [
|
'outcome' => 'failed_permanent',
|
'result' => 'Could not update items'
|
];
|
}
|
} else {
|
$success = $errors = [];
|
//Does not have batch update, manually update each one
|
foreach ($items as $item) {
|
$itemResult = $this->updateOne($item);
|
if (!is_wp_error($itemResult)) {
|
$success[] = $itemResult;
|
} else {
|
$errors[] = $itemResult;
|
}
|
}
|
|
$result = [
|
'outcome' => empty($errors) ? 'success' : (empty($success) ? 'failed' : 'partial'),
|
'result' => [
|
'success' => $success,
|
'errors' => $errors
|
]
|
];
|
}
|
|
return array_merge($result, $newlyCreated);
|
}
|
|
/**
|
* To be implemented by integration extension. Updates a single item
|
* @param array $item
|
* @return array|WP_Error
|
*/
|
protected function updateOne(array $item):array|WP_Error
|
{
|
return new WP_Error('invalid', 'Integration '.$this->service_name.' must implement its own updateOne method');
|
}
|
|
/**
|
* Overridden by child classes
|
* @param array $items
|
* @return array|WP_Error
|
*/
|
protected function sendBatchUpdate(array $items):array|WP_Error
|
{
|
return new WP_Error('invalid', 'Integration '.$this->service_name.' must implement its own sendBatchUpdate');
|
}
|
|
|
/**
|
* To be implemented by extensions
|
* @param array $data
|
* @param array $response
|
* @return array
|
*/
|
protected function processBatchUpdateResponse(array $data, array $response):array
|
{
|
return [
|
'outcome' => 'failed',
|
'result' => [
|
'message' => $this->service_name.' should implement processBatchUpdateResponse.'
|
]
|
];
|
}
|
/*****************************************************************
|
* UTILITY
|
*****************************************************************/
|
protected function noUpdatedItems(array $created):array
|
{
|
$result = [
|
'outcome' => 'success',
|
'result' => [
|
'message' => 'No items to update',
|
'updated' => [],
|
'errors' => [],
|
]
|
];
|
|
if (!empty($created)) {
|
error_log('Result before: '.print_r($result, true));
|
$result = array_merge($result, $created);
|
error_log('Result after merge: '.print_r($result, true));
|
}
|
return $result;
|
}
|
|
protected function noCreatedItems(array $updated):array
|
{
|
$result = [
|
'outcome' => 'success',
|
'result' => [
|
'message' => 'No items to create',
|
'created' => [],
|
'errors' => [],
|
]
|
];
|
if (!empty($updated)) {
|
$result = array_merge($result, $updated);
|
}
|
return $result;
|
}
|
|
/****************************************************************
|
* UTILITY
|
****************************************************************/
|
protected function getSyncFields(int $itemID, string $type, array $additionalFields = []):array
|
{
|
$meta = match ($type) {
|
'post' => Meta::forPost($itemID),
|
'term' => Meta::forTerm($itemID),
|
'user' => Meta::forUser($itemID),
|
default => false
|
};
|
if (!$meta) {
|
return [];
|
}
|
|
$fields = [
|
'share_to_' . $this->service_name,
|
'_keep_synced_' . $this->service_name,
|
"_{$this->service_name}_item_id",
|
"_{$this->service_name}_last_sync",
|
"_{$this->service_name}_shared_at",
|
"_{$this->service_name}_sync_status",
|
"_{$this->service_name}_scheduled_at",
|
... $additionalFields
|
];
|
return $meta->getAll($fields);
|
}
|
/****************************************************************
|
* POST SYNC
|
****************************************************************/
|
public function addSavePost():void
|
{
|
if (!has_action('save_post', [$this, 'handleSavePost'])) {
|
add_action('save_post', [$this, 'handleSavePost'], 20, 3);
|
}
|
}
|
public function removeSavePost():void
|
{
|
remove_action('save_post', [$this, 'handleSavePost'], 20, 3);
|
}
|
public function handleSavePost(int $postID, WP_Post $post, bool $update):void
|
{
|
if (defined('DOING_AUTOSAVE') && DOING_AUTOSAVE) return;
|
if (wp_is_post_revision($postID)) return;
|
|
error_log('=== ['.$this->service_name.']::handleSavePost called');
|
|
$postType = jvbNoBase($post->post_type);
|
if (!in_array($postType, $this->syncPostTypes)) {
|
error_log('Not handling save for '.$this->service_name.' because there are no syncPostTypes: '.print_r($this->syncPostTypes, true));
|
return;
|
}
|
|
$registrar = Registrar::getInstance($postType);
|
//Should not happen, as syncPostTypes is defined by Registrar instances
|
if (!$registrar) {
|
return;
|
}
|
|
$settings = $registrar->getIntegrationConfig($this->service_name);
|
if (!$settings) {
|
error_log('Not handling save for '.$this->service_name.' because of no integration config '.print_r($settings, true));
|
return;
|
}
|
|
$fields = $this->getSyncFields($postID, 'post');
|
if (!$fields['share_to_'.$this->service_name]) {
|
error_log('Not handling save for '.$this->service_name.' because of no share_to_'.$this->service_name.' '.print_r($fields, true));
|
return;
|
}
|
|
$isShared = array_key_exists("_{$this->service_name}_item_id", $fields) && !empty($fields["_{$this->service_name}_item_id"]);
|
|
if ($post->post_status !== 'publish' && !$isShared) {
|
error_log('Not handling save for '.$this->service_name.' because post status is not publish, and it is not already shared.');
|
return;
|
}
|
|
if ($isShared && $update && !$fields['_keep_synced_'.$this->service_name]) {
|
error_log('Not handling save for '.$this->service_name.' because it is already shared, and not set to keep synced. ');
|
return;
|
}
|
error_log('==== Sending to integration\'s handleTheSavePost '.$this->service_name.' ====');
|
$this->removeSavePost();
|
$this->handleTheSavePost($postID, $post, $update, $settings);
|
$this->addSavePost();
|
}
|
/**
|
* Handle post save for syncing
|
*
|
* Override to implement custom sync logic when posts are saved.
|
* Check the $settings array for post type specific configuration.
|
*
|
* @param int $postID The post ID
|
* @param WP_Post $post The post object
|
* @param bool $update Whether this is an update
|
* @param array $settings Post type integration settings
|
* @return void
|
*/
|
protected function handleTheSavePost(int $postID, WP_Post $post, bool $update, array $settings):void
|
{
|
error_log('==== ['.$this->title.']::handleTheSavePost ====');
|
$this->queueOperation(self::$syncTo, [
|
'posts' => [$postID],
|
'user' => user_can($post->post_author, 'manage_options') ? null : $post->post_author
|
], [
|
'priority' => 'high',
|
'delay' => 30,
|
]);
|
Meta::forPost($postID)->set('_'.$this->service_name.'_sync_status', 'queued');
|
}
|
|
public function addDeletePost():void
|
{
|
if (!has_action('before_delete_post', [$this, 'handleDeletePost'])) {
|
add_action('before_delete_post', [$this, 'handleDeletePost'], 20, 3);
|
}
|
}
|
public function removeDeletePost():void
|
{
|
remove_action('before_delete_post', [$this, 'handleSavePost'], 20, 3);
|
}
|
public function handleDeletePost(int $postID):void
|
{
|
if (!$this->canSync['delete']) {
|
return;
|
}
|
$postType = get_post_type($postID);
|
if (!in_array(jvbNoBase($postType), $this->syncPostTypes)) {
|
return;
|
}
|
$fields = $this->getSyncFields($postID, 'post');
|
if (empty($fields["_{$this->service_name}_item_id"])) {
|
return;
|
}
|
$post = get_post($postID);
|
if (!$post) {
|
return;
|
}
|
$userID = $this->determineUserID($post->post_author);
|
if (!$userID) {
|
return;
|
}
|
|
JVB()->queue()->add(
|
self::$deleteFrom,
|
$userID,
|
[
|
'fields' => [$postID => $fields],
|
'service' => $this->service_name,
|
'type' => 'post'
|
]
|
);
|
}
|
/****************************************************************
|
* TERM SYNC
|
****************************************************************/
|
public function addSaveTerm():void
|
{
|
if (empty($this->syncTaxonomies)) {
|
return;
|
}
|
if (!has_action('saved_term', [$this, 'handleSaveTerm'])) {
|
add_action('saved_term', [$this, 'handleSaveTerm'], 20, 3);
|
}
|
}
|
public function removeSaveTerm():void
|
{
|
if (empty($this->syncTaxonomies)) {
|
return;
|
}
|
remove_action('saved_term', [$this, 'handleSaveTerm'], 20, 3);
|
}
|
protected function handleSaveTerm(int $termID, int $tt_id, string $taxonomy, bool $update, array $args):void
|
{
|
$tax = jvbNoBase($taxonomy);
|
if (!in_array($tax, $this->syncTaxonomies)) {
|
return;
|
}
|
$registrar = Registrar::getInstance($tax);
|
if (!$registrar) {
|
return;
|
}
|
|
$settings = $registrar->getIntegrationConfig($this->service_name);
|
if (!$settings) {
|
return;
|
}
|
|
$fields = $this->getSyncFields($termID, 'term');
|
if (!$fields['share_to_'.$this->service_name]) {
|
return;
|
}
|
|
$isShared = array_key_exists("_{$this->service_name}_item_id", $fields) && !empty($fields["_{$this->service_name}_item_id"]);
|
|
if ($isShared && $update && !$fields['_keep_synced_'.$this->service_name]) {
|
return;
|
}
|
$this->removeSaveTerm();
|
$this->handleTheSaveTerm($termID, $update, $taxonomy, $settings);
|
$this->addSaveTerm();
|
}
|
|
/**
|
* @param int $termID
|
* @param bool $update
|
* @param array $settings
|
* @return void
|
*/
|
protected function handleTheSaveTerm(int $termID, bool $update, string $taxonomy, array $settings):void
|
{
|
error_log('==== ['.$this->title.']::handleTheSaveTerm ====');
|
//TODO: Figure out some sort of permissions for if the user can share this term, particularly for content types
|
//TODO: If this is a content type, it likely has its own integration. This is an edmonton.ink problem, so I'm offloading it for now
|
$this->queueOperation(self::$syncTo, [
|
'terms' => [$termID],
|
'user' => get_current_user_id(),
|
], [
|
'priority' => 'high',
|
'delay' => 30,
|
]);
|
Meta::forTerm($termID)->set('_'.$this->service_name.'_sync_status', 'queued');
|
}
|
|
public function addDeleteTerm():void
|
{
|
if (!has_action('pre_delete_term', [$this, 'handleDeleteTerm'])) {
|
add_action('pre_delete_term', [$this, 'handleDeleteTerm']);
|
}
|
}
|
public function removeDeleteTerm():void
|
{
|
remove_action('pre_delete_term', [$this, 'handleDeleteTerm']);
|
}
|
public function handleDeleteTerm(int $termID, string $taxonomy):void
|
{
|
if (!$this->canSync['delete']) {
|
return;
|
}
|
$tax = jvbNoBase($taxonomy);
|
if (!in_array($tax, $this->syncTaxonomies)) {
|
return;
|
}
|
$fields = $this->getSyncFields($termID, 'term');
|
if (empty($fields["_{$this->service_name}_item_id"])) {
|
return;
|
}
|
JVB()->queue()->add(
|
self::$deleteFrom,
|
0,
|
[
|
'fields' => [$termID => $fields],
|
'service' => $this->service_name,
|
'type' => 'term'
|
]
|
);
|
}
|
|
/****************************************************************
|
* USER SYNC
|
****************************************************************/
|
public function addSaveUser():void
|
{
|
if (empty($this->syncUsers)) {
|
return;
|
}
|
if (!has_action('profile_update', [$this, 'handleUpdateUser'])) {
|
add_action('profile_update', [$this, 'handleUpdateUser'], 20, 1);
|
}
|
if (!has_action('user_register', [$this, 'handleUpdateUser'])) {
|
add_action('user_register', [$this, 'handleUpdateUser'], 20, 1);
|
}
|
}
|
public function removeSaveUser():void
|
{
|
if (empty($this->syncUsers)) {
|
return;
|
}
|
remove_action('profile_update', [$this, 'handleUpdateUser'], 20);
|
remove_action('user_register', [$this, 'handleUpdateUser'], 20);
|
}
|
protected function handleUpdateUser(int $userID):void
|
{
|
$user = $this->getOrCreateUser($userID);
|
if (!$user) {
|
return;
|
}
|
|
$fields = $this->getSyncFields($userID, 'user');
|
if (!empty($fields["_{$this->service_name}_item_id"])) {
|
return;
|
}
|
|
$this->removeSaveUser();
|
$this->handleTheSaveUser($userID);
|
$this->addSaveTerm();
|
}
|
|
protected function getOrCreateUser(int $userID):string|false
|
{
|
$user = get_userdata($userID);
|
if (!$user || is_wp_error($user)) {
|
return false;
|
}
|
$role = jvbUserRole($userID);
|
if (!in_array(jvbNoBase($role), $this->syncUsers)) {
|
return false;
|
}
|
$fields = $this->getSyncFields($userID, 'user');
|
if (!empty($fields["_{$this->service_name}_item_id"])) {
|
return $fields["_{$this->service_name}_item_id"];
|
}
|
|
$meta = Meta::forUser($userID);
|
$serviceUserID = $this->searchServiceForUser($user->user_email??'');
|
if ($serviceUserID) {
|
$meta->set("{$this->service_name}_item_id", $serviceUserID);
|
return $serviceUserID;
|
}
|
|
$created = $this->createServiceUser($userID, $fields);
|
if ($created) {
|
return $created;
|
}
|
return false;
|
}
|
public function searchServiceForUser(string $email):string|false
|
{
|
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
|
return false;
|
}
|
return $this->handleEmailSearch($email);
|
}
|
|
/**
|
* Searches for existing user from sanitized email
|
* @param string $email
|
* @return string|false The found service's User ID or false on failure
|
*/
|
abstract public function handleEmailSearch(string $email):string|false;
|
|
public function createServiceUser(int $userID, array $fields):string|false
|
{
|
$checked = $this->validateUserFields($userID, $fields);
|
$response = $this->handleCreateUser($checked);
|
if ($response['success']) {
|
$meta = Meta::forUser($userID);
|
$meta->set("{$this->service_name}_item_id", $response['result']['id']);
|
}
|
return $response['success'] ? $response['customer']??false : false;
|
}
|
|
protected function validateUserFields(int $userID, array $fields):array|false
|
{
|
foreach ($fields as $f => $v) {
|
$v = match ($f) {
|
'email' => filter_var($v, FILTER_SANITIZE_EMAIL),
|
'phone' => Sanitizer::sanitizePhone($v),
|
default => sanitize_text_field($v),
|
};
|
if (empty($v) && in_array($f, $this->requiredUserFields())) {
|
return false;
|
}
|
$fields[$f] = $v;
|
}
|
return $fields;
|
}
|
protected function requiredUserFields():array
|
{
|
return [];
|
}
|
|
/**
|
* @param array $data User Data
|
* @return array The created user ID or false on failure
|
*/
|
abstract protected function handleCreateUser(array $data):array;
|
|
/**
|
* @param int $userID
|
* @return void
|
*/
|
protected function handleTheSaveUser(int $userID):void
|
{
|
error_log('==== ['.$this->title.']::handleTheSaveUser ====');
|
//TODO: This is likely only for stuff like customers.
|
//If we have multiple stores connected, we may have to queue operations to update every connection's customer account if they made an order with that store
|
$role = jvbUserRole($userID);
|
$registrar = Registrar::getInstance($role);
|
if (!$registrar || !$registrar->hasIntegration($this->service_name)) {
|
return;
|
}
|
|
$this->queueOperation(self::$syncTo, [
|
'users' => [$userID],
|
]);
|
}
|
|
public function addDeleteUser():void
|
{
|
if (!has_action('delete_user', [$this, 'handleDeleteTerm'])) {
|
add_action('delete_user', [$this, 'handleDeleteTerm']);
|
}
|
}
|
public function removeDeleteUser():void
|
{
|
remove_action('delete_user', [$this, 'handleDeleteTerm']);
|
}
|
public function handleDeleteUser(int $userID):void
|
{
|
if (!$this->canSync['delete']) {
|
return;
|
}
|
|
$fields = $this->getSyncFields($userID, 'user');
|
if (empty($fields["_{$this->service_name}_item_id"])) {
|
return;
|
}
|
JVB()->queue()->add(
|
self::$deleteFrom,
|
0,
|
[
|
'fields' => [$userID => $fields],
|
'service' => $this->service_name,
|
'type' => 'user'
|
]
|
);
|
}
|
}
|
