phpsa / datastore

src/Datastore.php

<?php

// @todo - move this to a smaller instance and move more of the logic to the Model itself

namespace Phpsa\Datastore;

use Phpsa\Datastore\Models\Datastore as DatastoreModel;
use Phpsa\Datastore\DatastoreException;
use Phpsa\Datastore\Asset;
use Phpsa\Datastore\Helpers;
use Illuminate\Support\Facades\Storage;
use Illuminate\Validation\ValidationException;
use Illuminate\Support\Carbon;
use Validator;
use ReflectionClass;
use ReflectionProperty;

class Datastore{

	protected $__asset				 = false;
	protected $__asset_properties	 = false;
	protected $__value_equals		 = false;
	protected $__status_equals		 = false;
	protected $__start_date			 = null;
	protected $__end_date			 = null;

	/**
	 *
	 * @var DatastoreModel
	 */
	protected $__model;

	/**
	 *
	 * @var array of datastore_model
	 */
	public $ownDatastore = false;

	/**
	 * The current record id

The type Phpsa\Datastore\record was not found. Maybe you did not declare it correctly or list all dependencies?

	 * @var record id
	 */
	public $id = 0;

	/**
	 * construct a new datastore instance
	 * if an id is passed populate the data
	 * @param int $id
	 */
	public function __construct($id = 0)
	{

		$this->id = $id;

It seems like $id of type integer is incompatible with the declared type Phpsa\Datastore\record of property $id.

		if ($id)
		{
			$this->__model = DatastoreModel::findOrFail($id);

			if(!$this->__model){
				//could not load <div class="">thr</div>
				throw new DatastoreException("Record not found");
			}

			foreach ($this->__model->toArray() as $k => $v)
			{
				if($k === 'options' || $k === 'meta'){
					$v = json_decode($v, true);
				}
				if(in_array($k, ['created_at','updated_at','date_start','date_end'])){
					$v = Carbon::parse($v);
				}
				$this->{$k} = $v;
			}


			$stores = $this->__model->properties;
			if ($stores)
			{
				foreach ($stores as $ds)
				{
					$this->ownDatastore[] = self::getAssetById($ds->id);
				}
			}
		}else{
			$this->__model = new DatastoreModel();
		}
	}

	/**
	 * Gets an existing asset by ID
	 *
	 * @param [type] $id

The doc comment [type] at position 0 could not be parsed: Unknown type name '[' at position 0 in [type].

	 *
	 * @return void
	 */
	public static function getAssetById($id){
		$datastore = new self($id);
		$datastore->setAssetType($datastore->type);
		return $datastore;

The expression return $datastore returns the type Phpsa\Datastore\Datastore which is incompatible with the documented return type void.

	}

	public static function find($id){
		if(!is_array($id)){
			if(is_object($id)){
				return self::getAssetById($id->id);
			}
			return self::getAssetById($id);
		}

		if(is_array($id)){

The condition is_array($id) is always true.

			$assets = [];
			foreach($id as $i){
				$assets[] = self::getAssetById($i);
			}
			return $assets;
		}
	}

	/**
	 * Gets a new asset instance
	 * @param string $type
	 * @param int $id
	 * @return \DF_Datastore

The type DF_Datastore was not found. Maybe you did not declare it correctly or list all dependencies?

	 */
	public static function getAsset($type, $id = false)
	{
		$ds = new self($id);

It seems like $id can also be of type false; however, parameter $id of Phpsa\Datastore\Datastore::__construct() does only seem to accept integer, maybe add an additional type check?

		$ds->setAssetType($type);
		return $ds;

The expression return $ds returns the type Phpsa\Datastore\Datastore which is incompatible with the documented return type DF_Datastore.

	}


	public function ownDatastore(){
		return ($this->ownDatastore)?$this->ownDatastore: array();
	}

	/**
	 * Sets the type of asset & maps identifier keys
	 * @param string $type
	 * @return DF_Datastore

The type Phpsa\Datastore\DF_Datastore was not found. Maybe you did not declare it correctly or list all dependencies?

	 */
	public function setAssetType($type)
	{

		$this->__asset = Asset::factory($type);

		foreach ($this->__asset as $k => $v)
		{
			if ($k != 'properties')
			{
				if ($k == 'value_equals')
				{
					$this->__value_equals = $v;
				}
				else if ($k == 'status_equals')
				{
					$this->__status_equals = $v;
				}
				else if ($k == 'start_date')
				{
					$this->__start_date = $v;
				}
				else if ($k == 'end_date')
				{
					$this->__end_date = $v;
				}
				else
				{
					$this->$k = (isset($this->$k)) ? $this->$k : $v;
				}
			}
		}
		$this->type = $type;

The property type does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

		$this->module = Helpers::getModule($type);

The property module does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

		$this->setInternals();

		return $this;

The expression return $this returns the type Phpsa\Datastore\Datastore which is incompatible with the documented return type Phpsa\Datastore\DF_Datastore.

	}


	/**
	 * Sets the internal mapping
	 * @todo - pehaps this should become protected ?
	 */
	public function setInternals()
	{

		foreach ($this->__asset->properties as $p => $v)
		{

			if (!isset($this->__asset_properties[$p]))
			{
				$this->__asset_properties[$p]['temp']					 = self::getAsset($this->__asset->properties[$p]['type']);

The property properties does not exist on boolean.

				$this->__asset_properties[$p]['temp']->name				 = (isset($this->__asset->properties[$p]['name'])) ? $this->__asset->properties[$p]['name'] : null;
				$this->__asset_properties[$p]['temp']->key				 = $p;
				$this->__asset_properties[$p]['temp']->private			 = (isset($this->__asset->properties[$p]['private'])) ? $this->__asset->properties[$p]['private'] : false; // accessibility
				$this->__asset_properties[$p]['temp']->value			 = (isset($this->__asset->properties[$p]['value'])) ? $this->__asset->properties[$p]['value'] : null; // the actual value of the property
				$this->__asset_properties[$p]['temp']->options			 = (isset($this->__asset->properties[$p]['options'])) ? $this->__asset->properties[$p]['options'] : null; // additional options specific to the property
				$this->__asset_properties[$p]['temp']->callback			 = (isset($this->__asset->properties[$p]['callback'])) ? $this->__asset->properties[$p]['callback'] : null; // additional options specific to the property
				$this->__asset_properties[$p]['temp']->meta				 = (isset($this->__asset->properties[$p]['meta'])) ? $this->__asset->properties[$p]['meta'] : null; // additional options specific to the property
				$this->__asset_properties[$p]['temp']->help				 = (isset($this->__asset->properties[$p]['help'])) ? $this->__asset->properties[$p]['help'] : null; // additional options specific to the property
				$this->__asset_properties[$p]['temp']->required			 = (isset($this->__asset->properties[$p]['required'])) ? $this->__asset->properties[$p]['required'] : true; // is the property required
				$this->__asset_properties[$p]['temp']->limit			 = (isset($this->__asset->properties[$p]['limit'])) ? $this->__asset->properties[$p]['limit'] : null; // additional options specific to the property
				$this->__asset_properties[$p]['temp']->warning			 = (isset($this->__asset->properties[$p]['warning'])) ? $this->__asset->properties[$p]['warning'] : null; // additional options specific to the property
				$this->__asset_properties[$p]['temp']->max_instances	 = (isset($this->__asset->properties[$p]['max_instances'])) ? $this->__asset->properties[$p]['max_instances'] : 0; // there can be only one
			}
		}

		// fitst check whether we have any datastore set
		if ($this->ownDatastore)

The expression $this->ownDatastore of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

		{

			// if it has a datastore, its easy - map the buggers
			$this->key = self::getKey($this->type);

The property key does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

			foreach ($this->ownDatastore as $idx => $each)
			{
				// create a map to our property bean
				if ($each->namespace == 'property')
				{
					$this->__asset_properties[$each->key]	 = array('temp' => $each);
					@$this->ownDatastore[$idx]->required		 = (isset($this->__asset->properties[$each->key]['required'])) ? $this->__asset->properties[$each->key]['required'] : true;
					@$this->ownDatastore[$idx]->limit		 = (isset($this->__asset->properties[$each->key]['limit'])) ? $this->__asset->properties[$each->key]['limit'] : null;
					@$this->ownDatastore[$idx]->warning		 = (isset($this->__asset->properties[$each->key]['warning'])) ? $this->__asset->properties[$each->key]['warning'] : null;
					@$this->ownDatastore[$idx]->help			 = (isset($this->__asset->properties[$each->key]['help'])) ? $this->__asset->properties[$each->key]['help'] : null;
					@$this->ownDatastore[$idx]->max_instances = (isset($this->__asset->properties[$each->key]['max_instances'])) ? $this->__asset->properties[$each->key]['max_instances'] : 0;
					@$this->ownDatastore[$idx]->options = (isset($this->__asset->properties[$each->key]['options'])) ? $this->__asset->properties[$each->key]['options'] : null;
				}
			}
			//echo '<pre>$this->ownDatastore: '; print_r($this->ownDatastore); echo '</pre>'; die();
		}
		else
		{
			// nope - net to create some datastore beans to represent our properties
			foreach ($this->__asset->properties as $prop => $data)
			{

				// we need to create a temporary new bean to store new data
				$this->__asset_properties[$prop]['temp']				 = self::getAsset($this->__asset->properties[$prop]['type']);
				$this->__asset_properties[$prop]['temp']->name			 = (isset($this->__asset->properties[$prop]['name'])) ? $this->__asset->properties[$prop]['name'] : null;
				$this->__asset_properties[$prop]['temp']->key			 = $prop;
				$this->__asset_properties[$prop]['temp']->private		 = (isset($this->__asset->properties[$prop]['private'])) ? $this->__asset->properties[$prop]['private'] : false; // accessibility
				$this->__asset_properties[$prop]['temp']->value			 = (isset($this->__asset->properties[$prop]['value'])) ? $this->__asset->properties[$prop]['value'] : null; // the actual value of the property
				$this->__asset_properties[$prop]['temp']->options		 = (isset($this->__asset->properties[$prop]['options'])) ? $this->__asset->properties[$prop]['options'] : null; // additional options specific to the property
				$this->__asset_properties[$prop]['temp']->callback		 = (isset($this->__asset->properties[$prop]['callback'])) ? $this->__asset->properties[$prop]['callback'] : null; // additional options specific to the property
				$this->__asset_properties[$prop]['temp']->meta			 = (isset($this->__asset->properties[$prop]['meta'])) ? $this->__asset->properties[$prop]['meta'] : null; // additional options specific to the property
				$this->__asset_properties[$prop]['temp']->help			 = (isset($this->__asset->properties[$prop]['help'])) ? $this->__asset->properties[$prop]['help'] : null; // additional options specific to the property
				$this->__asset_properties[$prop]['temp']->required		 = (isset($this->__asset->properties[$prop]['required'])) ? $this->__asset->properties[$prop]['required'] : true; // is the property required
				$this->__asset_properties[$prop]['temp']->limit			 = (isset($this->__asset->properties[$prop]['limit'])) ? $this->__asset->properties[$prop]['limit'] : null; // additional options specific to the property
				$this->__asset_properties[$prop]['temp']->warning		 = (isset($this->__asset->properties[$prop]['warning'])) ? $this->__asset->properties[$prop]['warning'] : null; // additional options specific to the property
				$this->__asset_properties[$prop]['temp']->max_instances	 = (isset($this->__asset->properties[$prop]['max_instances'])) ? $this->__asset->properties[$prop]['max_instances'] : null; // there can be only one

			}
		}
	}



	/**
	 * Gets the Asset Key
	 * @param string $string
	 * @return string
	 */
	public static function getKey($string)
	{
		$new	 = Helpers::splitByCaps($string);
		$explode = explode(' ', $new);

		if (isset($explode[0]) && $explode[0] == 'Ams')
		{
			// drop the ams portion
			array_shift($explode);
		}
		// drop the last part too
		$last = array_pop($explode);

The assignment to $last is dead and can be removed.

		//lowercase the first part
		if (isset($explode[0]))
		{
			$explode[0] = strtolower($explode[0]);
		}

		return (count($explode) > 1) ? implode('', $explode) : $explode[0];
	}

	/**
	 * Setter / getter of asset property value,
	 * pass 1 param to get the value,
	 * pass 2 params to set the value
	 * @return mixed
	 * @throws Exception
	 */
	public function prop()
	{
		$num_args = func_num_args();

		// one arg, return prop by key
		// two args set prop by name to arg2
		switch ($num_args)
		{
			case 1:
				$prop = func_get_arg(0);
				if (isset($this->__asset_properties[$prop]))
				{
					// check whether this is new or existibng
					if (isset($this->__asset_properties[$prop]['temp']))
					{
						return $this->__asset_properties[$prop]['temp']->value;
					}
					else
					{
						return $this->ownDatastore[$this->__asset_properties[$prop]]->value;
					}
				}
				else
				{
					return false;
				}
				break;

			case 2:
				$prop	 = func_get_arg(0);
				$val	 = func_get_arg(1);
				if (isset($this->__asset_properties[$prop]))
				{
					// check whether this is new or existing
					if (isset($this->__asset_properties[$prop]['temp']))
					{
						$this->__asset_properties[$prop]['temp']->value = $val;
						// if value equals is set, set it too

						if ($this->__value_equals && $this->__value_equals == $prop)
						{
							$this->val(Helpers::callStatic($this->type, 'valueEquals', array($val)));
						}
						else if ($this->__status_equals && $this->__status_equals == $prop)
						{
							$this->status($val);
						}
						else if ($this->__start_date && $this->__start_date == $prop)
						{
							$this->start_date($val);

The method start_date() does not exist on Phpsa\Datastore\Datastore.

						}
						else if ($this->__end_date && $this->__end_date == $prop)
						{
							$this->end_date($val);

The method end_date() does not exist on Phpsa\Datastore\Datastore.

						}
					}
					else
					{
						$this->ownDatastore[$this->__asset_properties[$prop]]->value = $val;
						// if value equals is set, set it too
						if ($this->__value_equals && $this->__value_equals == $prop)
						{
							$this->val(Helpers::callStatic($this->type, 'valueEquals', array($val)));
						}
						else if ($this->__status_equals && $this->__status_equals == $prop)
						{
							$this->status($val);
						}
						else if ($this->__start_date && $this->__start_date == $prop)
						{
							$this->start_date($val);
						}
						else if ($this->__end_date && $this->__end_date == $prop)
						{
							$this->end_date($val);
						}
					}
					return $this;
				}
				else
				{
					throw new DatastoreException('The property "' . $prop . '" is not defined for the "' . $this->type . '" asset');
				}
				break;

			default:
				throw new DatastoreException('DF_Datastore::prop accepts either a property name, or a property and value');
		}
	}

	/**
	 *  shortcut to write to the asset's value property
	 * @return mixed
	 */
	public function val()
	{
		$num_args = func_num_args();

		switch ($num_args)
		{
			case 0:
				// return all props as beans
				return $this->value;
				break;

break is not strictly necessary here and could be removed.

			default:
				$val		 = func_get_arg(0);
				$this->value = $val;

The property value does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

		}
	}

	public function __toString()
	{

		return (string) $this->val();
	}

	/**
	 * Stores our asset
	 * @param DF_Datastore $asset
	 * @param Int $pid Parent Datastore id
	 */
	protected function __store($asset, $pid = null)
	{

		$class	 = new ReflectionClass($asset->__asset);
		$props	 = $class->getProperties(ReflectionProperty::IS_PUBLIC);
		$record = $asset->__model;
		$record->datastore_id = $pid;

		foreach ($props as $prop)
		{
			if (!in_array($prop->name, array('status_equals', 'properties','help','value_equals')))
			{
				$record->{$prop->name} = isset($asset->{$prop->name}) ? $asset->{$prop->name} : NULL;
			}
		}

		if ($asset->__status_equals)
		{
			$record->status = isset($record->{$asset->__status_equals})? $record->{$asset->__status_equals} : $this->prop($this->__status_equals);
		}
		if ($asset->__start_date)
		{
			$record->start_date = isset($record->{$asset->__start_date})? $record->{$asset->__start_date} : $this->prop($this->__start_date);
		}
		if ($asset->__end_date)
		{
			$record->end_date = isset($record->{$asset->__end_date})? $record->{$asset->__end_date} : $this->prop($this->__end_date);
		}

		$record->options = json_encode($record->options);
		$record->meta = json_encode($record->meta);

		$record->save();

		if ($asset->__asset_properties)
		{
			foreach ($asset->__asset_properties as $prop)
			{
				$this->__store($prop['temp'], $record->id);
			}
		}
		return $record->id;
	}

	/**
	 * Stores the asset
	 * @return int Datastore id
	 */
	public function store($parent = null)
	{

		return $this->__store($this, $parent);
	}

	/**
	 * Echos out the asset markup
	 * @param string $prop
	 * @param string $template
	 */
	public function render($prop, $template = false)
	{
		if (isset($this->__asset_properties[$prop]['temp']))
		{
			return $this->__asset_properties[$prop]['temp']->getMarkup($template);
		}
		else
		{
			if (isset($this->__asset_properties[$prop]))
			{
				return $this->ownDatastore[$this->__asset_properties[$prop]]->getMarkup($template);
			}
		}
	}

	/**
	 * Gets the current Datastore markup
	 * @param string $template
	 * @return string
	 */
	public function getMarkup($template = false)
	{

		$vars				 = $this->export();
		$vars['_unique_id']	 = uniqid();

		// we also want to know what asset this property belongs to
		$output = Helpers::callStatic($this->type, 'render', array($vars, $template));
		if (!$output)
		{
			return null;
		}
		return $output;
	}


	/**
	 * exports current Datastore to an array
	 * @return array
	 */
	public function export()
	{

		$class	 = new ReflectionClass($this->__asset);
		$props	 = $class->getProperties(ReflectionProperty::IS_PUBLIC);



		foreach ($props as $prop)
		{

			$data[$prop->name] = isset($this->{$prop->name}) ? $this->{$prop->name} : NULL;
		}

		if ($this->__status_equals)
		{

			$data['status'] = isset($data[$this->__status_equals])? $data[$this->__status_equals] : $this->prop($this->__status_equals);

The variable $data seems to be defined by a foreach iteration on line 522. Are you sure the iterator is never empty, otherwise this variable is not defined?

		}
		if ($this->__start_date)
		{
			$data['start_date'] = $data[$this->__start_date];
		}
		if ($this->__end_date)
		{
			$data['end_date'] = $data[$this->__end_date];
		}

		$data['id'] = $this->id;

		return $data;
	}


	/**
	 * Gets form element for a propery
	 * @param string $prop
	 * @param string $template
	 */
	public function form($prop, $template = false)
	{
		if (isset($this->__asset_properties[$prop]['temp']))
		{
			echo $this->__asset_properties[$prop]['temp']->getForm($template, $prop);
		}
		else
		{
			if (isset($this->__asset_properties[$prop]))
			{
				echo $this->ownDatastore[$this->__asset_properties[$prop]]->getForm($template, $prop);
			}
		}
	}

	/**
	 * Gets property form markup
	 * @param string $prop
	 * @param string $template
	 * @param array $_prop
	 * @return type

The type Phpsa\Datastore\type was not found. Maybe you did not declare it correctly or list all dependencies?

	 */
	public function returnForm($prop, $template = false, $_prop)
	{

		if (isset($this->__asset_properties[$prop]['temp']))
		{
			return $this->__asset_properties[$prop]['temp']->getForm($template, $_prop);
		}
		else
		{
			if (isset($this->__asset_properties[$prop]))
			{

				return $this->ownDatastore[$this->__asset_properties[$prop]]->getForm($template, $_prop);
			}
		}
	}

	public function getFieldValues(){
		$data = [];
		foreach(array_keys($this->__asset->properties) as $key){

The property properties does not exist on boolean.

			$data[$key] = $this->prop($key);
		}
		return $data;
	}


	/**
	 * Gets the form
	 * @param string $template
	 * @param array $_prop
	 * @return string
	 */
	public function getForm($template = false, $_prop = array())
	{

		$output = null;
		if ($this->namespace == 'asset')

The condition $this->namespace == 'asset' is always false.

The property namespace does not exist on Phpsa\Datastore\Datastore. Since you implemented __get, consider adding a @property annotation.

		{
			foreach ($this->__asset_properties as $prop => $val)
			{
				$output .= $this->returnForm($prop, false, $_prop);
			}
		}
		else
		{
			return $this->propGetForm($template, $_prop);

It seems like $template can also be of type false; however, parameter $template of Phpsa\Datastore\Datastore::propGetForm() does only seem to accept string, maybe add an additional type check?

		}

		if (!$output)
		{
			return null;
		}
		return $output;
	}

	/**
	 * Gets property form
	 * @param string $template
	 * @param array $_prop
	 * @return string
	 */
	public function propGetForm($template = false, $_prop = array())
	{
		$vars = $this->export();

		if (isset($_prop['unique_id']))
		{
			$vars['_unique_id'] = $_prop['unique_id'];
		}
		else
		{
			$vars['_unique_id'] = md5(uniqid(rand(), true)); //UUID ??
		}

		// we also want to know what asset this property belongs to
		$output = Helpers::callStatic($this->type, 'form', array($vars, $template));
		if (!$output)
		{
			return null;
		}
		return $output;
	}

	public function propGetValue($prop){
		dd($prop);
	}

	/**
	 * Injects a form into an asset
	 * Children asset instances
	 * @param string $uid
	 * @return string
	 */
	public function injectForm($uid)
	{

		$output = null;
		if ($uid)
		{
			$unique_id = md5($uid);
		}
		else
		{
			$unique_id = md5(uniqid(rand(), true));
		}


		foreach ($this->__asset_properties as $prop => $each)

The expression $this->__asset_properties of type boolean is not traversable.

		{
			if (isset($this->__asset_properties[$prop]['temp']))
			{
				$xvars				 = $this->__asset_properties[$prop]['temp']->export();
				$xvars['unique_id']	 = $unique_id;

				$output .= Helpers::callStatic($this->__asset_properties[$prop]['temp']->type, 'form', array($xvars, $this->type));
			}
			else
			{
				if (isset($this->__asset_properties[$prop]))
				{
					$xvars				 = $this->ownDatastore[$this->__asset_properties[$prop]]->export();
					$xvars['unique_id']	 = $unique_id;

					$output .= Helpers::callStatic($this->ownDatastore[$this->__asset_properties[$prop]]->type, 'form', array($xvars, $this->type));
				}
			}
		}

		// we also want to know what asset this property belongs to
		$output .= '<input type="hidden" class="asset-injector-input" data-type="' . $this->type . '" id="' . $unique_id . '" name="assetInjectionform[' . $this->type . '][' . $unique_id . '][id]" value="' . $this->id . '" />';
		if (!$output)
		{
			return null;
		}
		return $output;
	}

	public function hasMetadataForm(){
		if ($this->namespace == 'asset' && !$this->is_child){

The condition $this->namespace == 'asset' is always false.

The property namespace does not exist on Phpsa\Datastore\Datastore. Since you implemented __get, consider adding a @property annotation.

The property is_child does not exist on Phpsa\Datastore\Datastore. Since you implemented __get, consider adding a @property annotation.

			return ($this->meta_description !== 'off' || $this->meta_keywords !== 'off');
		}
		return false;
	}

	/**
	 *  gets the form necessary for building the meta data
	 * @return string
	 */
	public function getMetadataForm()
	{
		$output = null;
		// must be a parent asset
		if ($this->namespace == 'asset' && !$this->is_child)

The property is_child does not exist on Phpsa\Datastore\Datastore. Since you implemented __get, consider adding a @property annotation.

The property namespace does not exist on Phpsa\Datastore\Datastore. Since you implemented __get, consider adding a @property annotation.

The condition $this->namespace == 'asset' is always false.

		{
			if ($this->meta_description !== 'off')
			{
				$data = array(
					'name'		 => 'Meta-Description',
					'key'		 => 'meta_description',
					'help'	 => 'You can associate a Meta-Description with this content. No more than 155 characters is considered optimal',
					'value'		 => $this->meta_description
				);

				$output .= Helpers::callStatic(ASSET::METATEXT, 'form', array($data, 'metatext'));
			}

			if ($this->meta_keywords !== 'off' /* &&  CONFIG->get('settings.allow_meta_keywords' ) */)
			{
				$data = array(
					'name'		 => 'Meta-Keywords',
					'key'		 => 'meta_keywords',
					'help'	 => 'You can associate Meta-Keywords with this content, with each keyword or key-phrase being seperated by a comma. <br/><b>Note :</b> There is evidence that suggests Keywords can hurt your SEO Ranking',
					'value'		 => $this->meta_keywords
				);

				$output .= Helpers::callStatic(ASSET::METATEXT, 'form', array($data, 'metatext'));
			}
		}
		if (!$output)

$output is of type null, thus it always evaluated to false.

		{
			return null;
		}
		return $output;
	}

	public function hasDeveloperForm(){
		if ($this->namespace == 'asset' && !$this->is_child){

The property namespace does not exist on Phpsa\Datastore\Datastore. Since you implemented __get, consider adding a @property annotation.

The property is_child does not exist on Phpsa\Datastore\Datastore. Since you implemented __get, consider adding a @property annotation.

The condition $this->namespace == 'asset' is always false.

			return ($this->page_js !== 'off' || $this->page_css !== 'off');
		}
		return false;
	}

	/**
	 *  gets the form necessary for building the styling and behaviour data
	 * @return string
	 */
	public function getDeveloperForm()
	{
		$output = null;
		// must be a parent asset
		if ($this->namespace == 'asset' && !$this->is_child)

The property is_child does not exist on Phpsa\Datastore\Datastore. Since you implemented __get, consider adding a @property annotation.

The property namespace does not exist on Phpsa\Datastore\Datastore. Since you implemented __get, consider adding a @property annotation.

The condition $this->namespace == 'asset' is always false.

		{
			if ($this->page_css !== 'off')
			{
				$data = array(
					'name'		 => 'Custom CSS',
					'key'		 => 'page_css',
					'help'	 	 => 'Custom css rules for this page display', // 'You can associate a Meta-Description with this content. No more than 155 characters is considered optimal',
					'value'		 => $this->page_css
				);

				$output .= Helpers::callStatic(ASSET::METATEXT, 'form', array($data, 'metatext'));
			}

			if ($this->page_js !== 'off' )
			{
				$data = array(
					'name'		 => 'Custom JS',
					'key'		 => 'page_js',
					'help'	 	 => 'custom javascript for this page display', // 'You can associate Meta-Keywords with this content, with each keyword or key-phrase being seperated by a comma. <br/><b>Note :</b> There is evidence that suggests Keywords can hurt your SEO Ranking',
					'value'		 => $this->page_js
				);

				$output .= Helpers::callStatic(ASSET::METATEXT, 'form', array($data, 'metatext'));
			}
		}
		if (!$output)

$output is of type null, thus it always evaluated to false.

		{
			return null;
		}
		return $output;
	}


	/**
	 * Validates the current form
	 * @return boolean if the form is valid or not
	 */
	public function validate($request = null)
	{

		$config = array();
		$messages = array();
		foreach ($this->__asset->properties as $key => $property)

The property properties does not exist on boolean.

		{
			if($property['type'] !== \Phpsa\Datastore\Ams\AutoCallBackAdderAsset::class && (empty($property['required']) || $property['required'] === true) )
			{
				$rules = empty($property['validation_rules']) ? 'required' : $property['validation_rules'];
				if(!empty($property['validation_messages'])){
					if(is_string($property['validation_messages'])){
						$messages[$key . '.required'] = $property['validation_messages'];
					}
				}
				$config[$key] = $rules;
			}

		}

		if ($config)
		{
			$validator = Validator::make($request, $config, $messages);

			if($validator->fails()){
				throw new ValidationException($validator);
			}
		}
		return true;
	}

	/**
	 * gets current datastore id
	 * @return int
	 */
	public function getId()
	{
		return $this->id;

The expression return $this->id returns the type Phpsa\Datastore\record which is incompatible with the documented return type integer.

	}

	/**
	 * Gets the current datastore children
	 * @return array
	 */
	public function children()
	{
		$return = false;

		if ($this->ownDatastore)

The expression $this->ownDatastore of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

		{
			foreach ($this->ownDatastore as $child => $child_bean)
			{
				if ($child_bean->namespace == 'asset')
				{
					$return[] = $child_bean;
				}
			}
		}
		return $return;

The expression return $return returns the type false which is incompatible with the documented return type array.

	}

	/**
	 * does this datastore have this property?
	 * @param string $prop
	 * @return boolean
	 */
	public function propExists($prop)
	{
		if (isset($this->__asset_properties[$prop]))
		{
			return true;
		}
		return false;
	}


	/**
	 * Populates the current Datastore with data passedin array
	 * @param array $post_data
	 * @return $this
	 */
	public function populateAsset($post_data = array())
	{

		foreach ($post_data as $k => $v)
		{
			switch ($k)
			{
				case 'meta_description':
				case 'meta_keywords':
					$this->$k = strip_tags($v);
					break;

				case 'page_css':
				case 'page_js':
					$this->$k = $v;
					break;

				case '_meta_':
					foreach ($v as $pr => $pv)
					{
						if ($this->propExists($pr))
						{
							if (isset($this->__asset_properties[$pr]))
							{
								// check whether this is new or existibng
								if (isset($this->__asset_properties[$pr]['temp']))
								{
									$this->__asset_properties[$pr]['temp']->meta = $pv;
								}
								else
								{
									$this->ownDatastore[$this->__asset_properties[$pr]]->meta = $pv;
								}
							}
						}
					}

				default:
					// if the property exists, populate the props
					if ($this->propExists($k))
					{
						$this->prop($k, $v);
					}
			}
		}

		return $this;
	}

	/**
	 * gets the avaialble status options
	 *
	 * @return void
	 */
	public function statusOptions(){
		return ($this->__status_equals) ? $this->__asset_properties[$this->__status_equals]['temp']->options : false;

The expression return $this->__status_equals ? $this->__asset_properties[$this->__status_equals]['temp']->options : false could also return false which is incompatible with the documented return type void. Did you maybe forget to handle an error condition?

	}

	/**
	 * Gets the readable version of the status
	 *
	 * @return void
	 */
	public function getStatusValue(){
		$options = $this->statusOptions();

Are you sure the assignment to $options is correct as $this->statusOptions() targeting Phpsa\Datastore\Datastore::statusOptions() seems to always return null.

		return ($options && Helpers::isAssocArray($options) && isset($options[$this->status])) ? $options[$this->status] : $this->status;

$options of type void is incompatible with the type array expected by parameter $array of Phpsa\Datastore\Helpers::isAssocArray().

$options is of type void, thus it always evaluated to false.

	}

	/**
	 * Get / set the current status value
	 *
	 * @return void
	 */
	public function status()
	{
		$num_args = func_num_args();

		 switch ($num_args)
		 {
			case 0:
				// return all props as beans
				return $this->status();

Are you sure the usage of $this->status() targeting Phpsa\Datastore\Datastore::status() seems to always return null.

				break;

break is not strictly necessary here and could be removed.

			default:
				$val = func_get_arg(0);
				$this->status = $val;

The property status does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

		 }
	}

	/**
	 * Checks to see if the current asset is actaully active
	 *
	 * @return bool
	 */
	public function statusIsActive(){
		if($this->__status_equals){

			if(!isset($this->__asset->properties[$this->__status_equals]['published'])){

The property properties does not exist on boolean.

				throw new DatastoreException("Statused assests need a published option in the asset definition");
			}

			$activeOptions = $this->__asset->properties[$this->__status_equals]['published'];

			return is_array($activeOptions) ? in_array($this->status, $activeOptions) : $activeOptions === $this->status;

		}
		return true;
	}


	/**
	 * gets the url for the image.
	 * @deprecated ???
	 * @todo - perhaps can be used based on record or moved better place ?
	 * @param [type] $image_id

The doc comment [type] at position 0 could not be parsed: Unknown type name '[' at position 0 in [type].

	 *
	 * @return void
	 */
	public static function image_url($image_id)

The parameter $image_id is not used and could be removed.

	{
		return Storage::url('file.jpg');

		// get_instance()->load->model('database/files_model');

		// $image = get_instance()->files_model->get_where(array('id' => $image_id), NULL, 1);

		// return ($image) ? $image->url() : 'assets/modules/blog/images/feature-placeholder.png';
	}

	/**
	 * Gets an asset by type and value
	 *
	 * @param [type] $type

The doc comment [type] at position 0 could not be parsed: Unknown type name '[' at position 0 in [type].

	 * @param [type] $value
	 * @deprecated ???
	 * @return void
	 */
	public static function getAssetByTypeValue($type,$value)
	{
		$asset = DatastoreModel::where('type' , $type)->where('value', $value)->where('namespace', 'asset')->orderBy('modified', 'desc')->first();
		if($asset){
			return self::getAsset($asset->type, $asset->id);

The expression return self::getAsset($asset->type, $asset->id) returns the type Phpsa\Datastore\Datastore which is incompatible with the documented return type void.

		}
		return false;

The expression return false returns the type false which is incompatible with the documented return type void.

	}

	/**
	 * Gets the url path for the current type
	 *
	 * @return void
	 */
	public function urlPath(){
		return Helpers::getPath($this->type);

Are you sure the usage of Phpsa\Datastore\Helpers::getPath($this->type) targeting Phpsa\Datastore\Helpers::getPath() seems to always return null.

	}



	/**
	 * Gets our view name
	 *
	 * @param string $prefix
	 *
	 * @return void
	 */
	public function getViewName($prefix = 'frontend.ams'){
		return $this->__asset::getAssetView($prefix);
	}

	/**
	 * Magic method to get from teh model if we not included it already
	 *
	 * @param [type] $name

The doc comment [type] at position 0 could not be parsed: Unknown type name '[' at position 0 in [type].

	 *
	 * @return void
	 */
	public function __get($name){
		return $this->propExists($name) ? $this->prop($name) : $this->__model->{$name};

The expression return $this->propExists($name) ? $this->prop($name) : $this->__model->$name could also return false which is incompatible with the documented return type void. Did you maybe forget to handle an error condition?

	}

	public function getTitleField(){
		return $this->__value_equals;
	}

}