Pages2JSON.module

<?php namespace ProcessWire;
/**
 * Pages2JSON
 *
 * Copyright:
 *
 * IDT Media - Goran Ilic & Tapio Löytty
 * Web: www.i-do-this.com
 * Email: hi@i-do-this.com
 *
 *
 * Authors:
 *
 * Goran Ilic, <ja@ich-mach-das.at>
 * Web: www.ich-mach-das.at
 * 
 * Tapio Löytty, <tapsa@orange-media.fi>
 * Web: www.orange-media.fi
 *
 * 
 * ProcessWire 2.x 
 * Copyright (C) 2014 by Ryan Cramer 
 * Licensed under GNU/GPL v2, see LICENSE.TXT
 * 
 * http://processwire.com
 *
 */

class Pages2JSON extends WireData implements Module, ConfigurableModule 
{
	#---------------------
	# Attributes
	#---------------------	

	static protected $static_fields = array(
		'id', 
		'name', 
		'url',
		'httpUrl',
		'template', 
		'parent', 
		'parent_id', 
		'created', 
		'modified', 
		'created_users_id', 
		'modified_users_id',
		'status'
	);

	#---------------------
	# Module init
	#---------------------	
	
	public function init() 
	{
		$this->addHook('Page::toJSON', $this, 'renderJSON');
		$this->addHook('WireArray::toJSON', $this, 'renderJSON');
	}
	
	public function ready() 
	{
		if($this->page->process == 'ProcessTemplate') {
			
			$this->addHookAfter('ProcessTemplate::buildEditForm', $this, 'appendJSONTab');		
			$this->addHookBefore('ProcessTemplate::executeSave', $this, 'JSONTabActions');	
		}
	}
	
	#---------------------
	# Interface methods
	#---------------------		
	
	static public function getModuleInfo() 
	{
		return array(
			'title' => 'Pages to JSON', 
			'author' => 'IDT Media',
			'version' => 005, 
			'summary' => 'Adds method to several wire classes to output as JSON',
			'singular' => true, 
			'autoload' => true
		);
	}	

	static public function getModuleConfigInputfields(array $data) 
	{
		$modules = wire('modules');
		$inputfields = new InputfieldWrapper();

		$displayFields = $modules->get('InputfieldAsmSelect'); 
		$displayFields->name = 'globalFields';
		$displayFields->label = 'Fields that will be included in results';
		
		foreach(self::$static_fields as $name) 
			if(!ctype_digit("$name")) $displayFields->addOption($name); 

		foreach(wire('fields') as $field) {
		
			if($field->type instanceof FieldtypeFieldsetOpen || $field->type instanceof FieldtypePassword) continue; 
			$displayFields->addOption($field->name); 
		}	

		$displayFields->value = isset($data['globalFields']) ? $data['globalFields'] : array();
		
		$inputfields->add($displayFields); 

		return $inputfields;
	}	
	
	#---------------------
	# Methods
	#---------------------
	
	public function encode($value, $options = 0, $depth = 512) 
	{
		return json_encode($this->getValue($value), $options, $depth);
	}

	public function process($value)
	{
		return $this->getValue($value);
	}
	
	#---------------------
	# Hooks
	#---------------------
	
	protected function renderJSON($event)
	{
		$options = $event->arguments(0) ? $event->arguments(0) : 0;
		
		$event->return = $this->encode($event->object, $options);
	}	

	protected function appendJSONTab($event)
	{
		$template = $event->arguments(0);

		if($template->flags & Template::flagSystem) 
			return;

		$f = wire('modules')->get('InputfieldAsmSelect'); 
		$f->name = 'json_fields';
		$f->icon = 'cogs';
		$f->label = $this->_x('JSON Fields', 'field-label');
		$f->description = $this->_('Fields that will be included in results for this template.');
		$f->collapsed = Inputfield::collapsedBlank;
		
		foreach(self::$static_fields as $name)
			if(!ctype_digit("$name")) $f->addOption($name);

		foreach($template->fields as $field) {
		
			if($field->type instanceof FieldtypeFieldsetOpen || $field->type instanceof FieldtypePassword) continue; 
			$f->addOption($field->name); 
		}	

		$f->value = $template->jsonFields;

		$form = $event->return;
		
		$t = $form->children->first(); // Basics tab
		$t->add($f);	
	}	
	
	protected function JSONTabActions($event)
	{
		// Grab current tempalte id
		$id = $this->input->id ? $this->input->id : -1;

		// Load template or fatal
		$template = $this->templates->get($id); 
		if(!$template) throw new WireException("Unknown template"); 

		// Set data
		$var = $this->input->post('json_fields');
		$template->set('jsonFields', $var);
	}		
	
	#---------------------
	# Helpers
	#---------------------	

	protected function getFields($page)
	{
		return self::isHooked('Pages2JSON::getFields()') ? $this->__call('getFields', array($page)) : $this->___getFields($page);
	}
		
	protected function ___getFields($page)
	{
		return (array)$this->globalFields;
	}
	
	protected function getValue($value)
	{
		return self::isHooked('Pages2JSON::getValue()') ? $this->__call('getValue', array($value)) : $this->___getValue($value);
	}
	
	protected function ___getValue($value)
	{
		// Handle everything that is not object as plain value
		if(!is_object($value))
			return $value;
		
		// Object is stdClass, we don't need exceptions
		if($value instanceof \stdClass)
			return $value;
	
		// Handle processwire internals
		switch(@$value->className) {

			case 'WireData':		
				return array_map(function($value) {
					return $this->getValue($value);
				}, $value->getArray());

			case 'Pageimage':
			case 'Pagefile':
				return array("url" => $value->url, "description" => $value->description);
		
			case 'MapMarker':
				return array("lat" => $value->lat, "lng" => $value->lng, "zoom" => $value->zoom, "address" => $value->address);			
		}	
	
		// Handle type of Page
		if($value instanceof Page)
			return $this->toPage($value);
		
		// Handle type of WireArray
		if($value instanceof \IteratorAggregate)
			return $this->toArray($value);
	
		// Unknown type :(
		return null;
	}

	protected function toPage(Page $page)
	{
		$of = $page->of();
		$page->of(false);

		$obj = new \stdClass;
		$fields = $this->getFields($page);
		$fields = array_merge($fields, (array)$page->template->jsonFields);

		foreach($fields as $field) {
		
			$value = $this->getValue($page->$field);
			
			if(!is_null($value))
				$obj->$field = $value;
		}
		
		$page->of($of);

		return $obj;
	}
	
	protected function toArray(\IteratorAggregate $array)
	{
		$out = array();
		foreach($array as $item) {

			$out[] = $this->getValue($item);
		}
	
		return $out;
	}
}