MillcoPush.module

<?php

namespace ProcessWire;

use Minishlink\WebPush\WebPush;
use Minishlink\WebPush\Subscription;

/**
 * MillcoPush
 * 
 * Playing around with push notifications,
 * 
 */


class MillcoPush extends WireData implements Module, ConfigurableModule
{

	public static function getModuleInfo()
	{
		return [
			'title' => 'MillcoPush',
			'summary' => 'Playing around with pushin',
			'version' => 1.1,
			'autoload' => true, // needs to be autoload for hooks.
			'singular' => true,
			'permanent' => false,
			'permission' => '',
			'icon' => 'arrow-right',
			'requires' => [
				'PHP>=8.0.0',
				'ProcessWire>=3.0.16',
			],
			'installs' => ['ProcessMillcoPush']
		];
	}

	// Add config fields.
	function getModuleConfigInputfields(InputfieldWrapper $inputfields)
	{

		// Add a new Inputfield to it
		$f = $this->wire('modules')->get('InputfieldText');
		$f->attr('name', 'public_key');
		// $f->attr('initValue', 'default thing');  
		$f->attr('value', $this->get('public_key'));

		$f->label = 'Public key';
		$inputfields->add($f);

		// Add a new Inputfield to it
		$f = $this->wire('modules')->get('InputfieldText');
		$f->attr('name', 'private_key');
		// $f->attr('initValue', 'default thing');  
		$f->attr('value', $this->get('private_key'));

		$f->label = 'Private key';
		$inputfields->add($f);

		return $inputfields;
	}

	static protected $defaults = array(
		'private_key' => '',
		'public_key' => ''

	);

	public function __construct()
	{
		// populate defaults, which will get replaced with actual
		// configured values before the init/ready methods are called
		// again this is done in ProcessMillcoPush now.
		$this->setArray(self::$defaults);
	}

	// 	init() method: This is called during the initialization after all modules have been loaded but before ProcessWire has fully bootstrapped and started delivering content.
	//  It’s the right place to add hooks or events that occur before page rendering starts.

	public function init()
	{
		/** @var MillcoPush $this */

		// Add a deck
		wire()->addHook('/millcopush/subscription/manage/', function ($event) {
			include('ajax_subscription_manage.php');
		});
	}

	//ready() method: This is called after ProcessWire is fully bootstrapped, and is about to start rendering a page. At this point, the entire API is available and ready for use. This method can be used when you depend on the current page being accessed, like changing or adding certain behaviors or settings based on the current page or user.
	public function ready() {}



	/**
	 * 
	 * If we have a public key then write out a subscribe
	 * button and the relevant javascript
	 * @return String $markup
	 */

	public function markup_subs_butts()
	{

		$public_key = $this->get('public_key');

		$markup = '';

		if ($public_key) {
			$markup .= wire('files')->render(wire('config')->paths->siteModules . 'MillcoPush/markup/subs_buttons.php', ['mp' => $this, 'public_key' => $public_key]);
		} else {

			$markup .= '<div class="alert">Missing public key.</div>';
		}

		return $markup;
	}


	/**
	 * Add a subscription
	 * @param Array $params
	 */

	public function subscription_add($sub_array)
	{

		$db = $this->wire('database');

		// TODO should check params here before trying
		// to do an update.

		$i = "INSERT INTO `millco_push_subscriptions` (
			user_key,
			mp_authToken,
			mp_contentEncoding,
			mp_endpoint,
			mp_subscription_json
			) VALUES (:user_key, :authtoken, :contentEncoding, :endpoint, :subscription_json);";

		$params = array(
			":user_key" => $sub_array['user_key'],
			":authtoken" => $sub_array['authToken'],
			":contentEncoding" => $sub_array['contentEncoding'],
			":endpoint" => $sub_array['endpoint'],
			":subscription_json" => $sub_array['subscription_json'],
		);

		$query = $db->prepare($i);
		$query->execute($params);

		return $db->lastInsertId();;
	}

	/**
	 * Delete a subscription
	 * @param Array $params
	 */

	public function subscription_delete($sub_array)
	{

		$db = $this->wire('database');

		$d = "DELETE  FROM `millco_push_subscriptions` WHERE
			user_key = :user_key
			AND mp_authToken = :authtoken
			LIMIT 10";

		$params = array(
			":user_key" => $sub_array['user_key'],
			":authtoken" => $sub_array['authToken']
		);

		$deleted = $db->prepare($d);
		$result = $deleted->execute($params);

		return $result;
	}

	/**
	 * Update a subscription
	 * Apparenrly the endpoint can change...
	 * @param Array $params
	 */

	public function subscription_update($sub_array)
	{

		$db = $this->wire('database');
		// let's also zero the strikes if we've updated the endpoint
		$q = "UPDATE `millco_push_subscriptions`
			SET  mp_endpoint=:mp_endpoint, strikes=0
			WHERE user_key= :user_key AND mp_authToken = :authtoken
			LIMIT 1
			";

		$params = array(
			":mp_endpoint" => $sub_array['endpoint'],
			":user_key" => $sub_array['user_key'],
			":authtoken" => $sub_array['authToken'],
		);

		$updated = $db->prepare($q);
		$result = $updated->execute($params);

		return $result;
	}


	/** 
	 * Send a notification to an array of users. For example, when a page that is being followed has been updated we can 
	 * pull out a list of users who are following and push a message to them.
	 * @param Array of user IDs
	 * @param String message
	 */

	function send_push_notification_to_users($users_array, $message, $url='')
	{

		// get subscription objects for these users.
		$user_subs = $this->users_subscriptions($users_array);

		require __DIR__ . '/webpush/vendor/autoload.php';

		// Build message options.
		$message_options=[];
		$message_options['message']= $message;
		// $message_options['icon']='/android-chrome-192x192.png';
		
		// if we've been passed a url then add it to our data value
		// We need to look for this click_action in the service worker js.
		if($url!='' && filter_var($url, FILTER_VALIDATE_URL)){
			$data=array("click_action"=>$url);
			$message_options['data'] = $data;
		}

		$message_options_json= json_encode($message_options);

		// array of notifications
		$notifications = [];

		// loop through our subscriptions and 
		// add them to our list
		foreach ($user_subs as $user_sub) {

			// store the client-side `PushSubscription` object (calling `.toJSON` on it) as-is and then create a WebPush\Subscription from it
			$subscription = Subscription::create(json_decode($user_sub['mp_subscription_json'], true));

			$notification = [];
			$notification['user_key'] = $user_sub['user_key'];
			$notification['subscription'] = $subscription;
			$notification['payload'] = $message_options_json;
	
			$notifications[] = $notification;
		}
		
		// TODO:

		$auth = array(
			'VAPID' => array(
				'subject' => 'https://millipedia.com/',
				'publicKey' => $this->get('public_key'),
				'privateKey' => $this->get('private_key')
			),
		);

		//  $defaultOptions = [
		// 	'TTL' => 300, // defaults to 4 weeks
		// 	'urgency' => 'normal', // protocol defaults to "normal". (very-low, low, normal, or high)
		// 	'topic' => 'Update', // not defined by default. Max. 32 characters from the URL or filename-safe Base64 characters sets
		// 	'batchSize' => 1000, // defaults to 1000
		// ];

		$webPush = new WebPush($auth);

		// $webPush->setDefaultOptions($defaultOptions);
		// send multiple notifications with payload
		foreach ($notifications as $notification) {
			$webPush->queueNotification(
				$notification['subscription'],
				$notification['payload'] // optional (defaults null)
			);
		}

		$notifications_sent=0;

		/**
		 * Check sent results
		 * @var MessageSentReport $report
		 */
		foreach ($webPush->flush() as $report) {
			$endpoint = $report->getRequest()->getUri()->__toString();

			if ($report->isSuccess()) {
				$notifications_sent++;
				$this->log("[v] Message sent successfully for subscription {$endpoint}.");
			} else {

				$this->log("[x] Message failed to sent for subscription {$endpoint}: {$report->getReason()}");

				// Add a strike against this endpoint.
				$this->strike($endpoint);


			}
		}

		return $notifications_sent;
	}


	/**
	 * Strike!
	 * If a message has failed to send then increment the strikes against it.
	 * We use the endpoint as a key ... cos hey, that's what we get back from WebPush
	 * 
	 * @var String $endpoint
	 */

	 public function strike($endpoint){

		$database = $this->wire('database');

		
		$sql = "SELECT strikes, user_key FROM `millco_push_subscriptions` WHERE `mp_endpoint` = :endpoint";
		$select = $database->prepare($sql);
		
		try {

			$select->execute([':endpoint' => $endpoint]);
			$row = $select->fetch();

			if($row['strikes'] > 3){

				//  We've had 3 goes. Let's delete this subscription.
				$query = $this->database->prepare("DELETE FROM `millco_push_subscriptions` WHERE mp_endpoint=:endpoint LIMIT 1");
				$delete_result = $query->execute(
					array(
						':endpoint' => $endpoint
					)
				);

				if($delete_result){
					$this->log("Subscription for user " . $row['user_key'] . " deleted");
				}else{
					$this->log("Unable to delete subscription for user " . $row['user_key'] . "");

				}

			}else{

				// increment strikes for this endpoint
				$sql = "UPDATE `millco_push_subscriptions` SET `strikes` = `strikes` + 1 WHERE `mp_endpoint` = :endpoint";
				$update = $database->prepare($sql);
				
				try {
					$update->execute([':endpoint' => $endpoint]);
				} catch (PDOException $e) {
					throw new WireException("Database query error: " . $e->getMessage());
				}


			}
		} catch (PDOException $e) {
			throw new WireException("Database query error: " . $e->getMessage());
		}
		
		
		
		// If this is the


	 }


	/**
	 * Return an array of unique user ids from the subscriptions table.
	 */

	public function subscribed_users()
	{

		// get a list of our subscribed users.
		$db = $this->wire('database');

		$q = "SELECT DISTINCT user_key
				FROM `millco_push_subscriptions`
				";

		$query = $db->prepare($q);
		$query->execute();

		$subscribed_users = $query->fetchAll();

		return $subscribed_users;
	}


	/**
	 * Return subscriptions for a user. 
	 * They might have subscribed several times of course
	 */

	public function user_subscriptions($user_key)
	{

		// get a list of our subscribed users.

		$db = $this->wire('database');

		$user_key = (int)$user_key;

		$q = "SELECT * FROM `millco_push_subscriptions` WHERE user_key = $user_key ";

		$query = $db->prepare($q);
		$query->execute();

		$users_subs = $query->fetchAll();

		return $users_subs;
	}


	/**
	 * Return subscriptions for an array of users. 
	 * They might have subscribed several times of course
	 * @param Array $user_key_array - an  array of user ids.
	 */

	public function users_subscriptions($user_key_array)
	{
		$db = $this->wire('database');

		$users_subs = array();

		if (is_array($user_key_array) && count($user_key_array)) {

			// pdo wants a string 
			$user_key_array_string = implode(',', $user_key_array);

			// $q = "SELECT * FROM `millco_push_subscriptions` WHERE user_key IN (:user_key_array_string)";

			// $params = array(
			// 	":user_key_array_string" => $user_key_array_string
			// );

			// $query = $db->prepare($q);
			// $query->execute($params);
			// $users_subs = $query->fetchAll();

			$q = "SELECT * FROM `millco_push_subscriptions` WHERE user_key IN ($user_key_array_string)";

			$query = $db->prepare($q);
			$query->execute();

			while($row=$query->fetch()){
				$users_subs[]=$row;
			}
			
		}


		return $users_subs;
	}


	public function notify_user($user_key, $message, $url='')
	{

		// All this does now is stick the user id into an 
		// array and pass it over to send_push_notification_to_users

		$users_array=[];
		$users_array[]=$user_key;
		$success=$this->send_push_notification_to_users($users_array,$message, $url);

		return $success;
	}

	public function ___install()
	{

		$database = $this->wire('database');

		$sql = "CREATE TABLE IF NOT EXISTS `millco_push_subscriptions` (
			`mp_id` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
			`user_key` INT(10) NOT NULL,
			`mp_authToken` VARCHAR(255) NOT NULL,
			`mp_contentEncoding` VARCHAR(255) NOT NULL,
			`mp_endpoint` VARCHAR(255) NOT NULL,
			`mp_subscription_json` TEXT NOT NULL,
			`strikes` INT NOT NULL DEFAULT 0
		);";

		try {
			$database->exec($sql);
		} catch (Exception $e) {
			$this->message("Could not create table: " . $e->getMessage());
		}
		return true;
	}


	public function ___uninstall()
	{

		$database = $this->wire('database');

		$sql = "DROP TABLE `millco_push_subscriptions`;";

		try {
			$database->exec($sql);
		} catch (Exception $e) {
			$this->message("Could not drop table: " . $e->getMessage());
		}

		return true;
	}


	/**
	 * Upgrade bits
	 */
	public function upgrade($fromVersion, $toVersion) {

        if ($fromVersion < 1.1) {

			$database = $this->wire('database');
			// Add the column 'strikes'
			$database->query("ALTER TABLE `millco_push_subscriptions` ADD `strikes` INT NOT NULL DEFAULT 0");
			$this->log("Subscriptions table updated to include strike col");
		}
    }

	
}