/**
* Checking to see that the inspector is set, handling the getProperty() methods, and handling the setProperty() methods.
* @param type $name
* @param type $arguments
* @return \Framework\Base
* @throws Exception
* @throws type
*/
public function __call($name, $arguments)
{
if (empty($this->_inspector)) {
throw new Exception("Call parent::__construct!");
}
$getMatches = StringMethods::match($name, "^get([a-zA-Z0-9_]+)\$");
if (sizeof($getMatches) > 0) {
$normalized = lcfirst($getMatches[0]);
$property = "_{$normalized}";
if (property_exists($this, $property)) {
$meta = $this->_inspector->getPropertyMeta($property);
if (empty($meta["@readwrite"]) && empty($meta["@read"])) {
throw $this->_getExceptionForWriteonly($normalized);
}
if (isset($this->{$property})) {
return $this->{$property};
}
return null;
}
}
$setMatches = StringMethods::match($name, "^set([a-zA-Z0-9_]+)\$");
if (sizeof($setMatches) > 0) {
$normalized = lcfirst($setMatches[0]);
$property = "_{$normalized}";
if (property_exists($this, $property)) {
$meta = $this->_inspector->getPropertyMeta($property);
if (empty($meta["@readwrite"]) && empty($meta["@write"])) {
throw $this->_getExceptionForReadonly($normalized);
}
$this->{$property} = $arguments[0];
return $this;
}
}
throw $this->_getExceptionForImplementation($name);
}
/**
* Uses a fairly simple regular expression to match key/value pairs within the Doc Comment string returned by any of our _get…Meta() methods.
* It does this using the StringMethods::match() method. It loops through all the matches, splitting them by key/value. If it finds no value component,
* it sets the key to a value of true. This is useful for flag keys such as @readwrite or @once.
* If it finds a value component, it splits the value by, and assigns an array of value parts to the key.
* Finally, it returns the key/value(s) associative array.
*
* @param type $comment string
* @return type associative array
*/
protected function _parse($comment)
{
$meta = array();
$pattern = "(@[a-zA-Z]+\\s*[a-zA-Z0-9, ()_]*)";
$matches = StringMethods::match($comment, $pattern);
if ($matches != null) {
foreach ($matches as $match) {
$parts = ArrayMethods::clean(ArrayMethods::trim(StringMethods::split($match, "[\\s]", 2)));
$meta[$parts[0]] = true;
if (sizeof($parts) > 1) {
$meta[$parts[0]] = ArrayMethods::clean(ArrayMethods::trim(StringMethods::split($parts[1], ",")));
}
}
}
return $meta;
}
public function __call($name, $arguments)
{
$getMatches = StringMethods::match($name, "^get([a-zA-Z0-9]+)\$");
if (sizeof($getMatches) > 0) {
$normalized = lcfirst($getMatches[0]);
$property = "_{$normalized}";
if (property_exists($this, $property)) {
return $this->{$property};
}
}
$setMatches = StringMethods::match($name, "^set([a-zA-Z0-9]+)\$");
if (sizeof($setMatches) > 0) {
$normalized = lcfirst($setMatches[0]);
$property = "_{$normalized}";
if (property_exists($this, $property)) {
$this->{$property} = $arguments[0];
return;
}
}
}
/**
* Check the Inspector is set and handle and getProperty(),
* setProperty() methods based upon metadata of defined properties
* @param string $name Name of property to be inspected
* @param array $arguments Paramerters to be passed to property
*/
public function __call($name, $arguments)
{
// Check class calls parent construct
if (empty($this->_inspector)) {
throw new \Exception("Call parent::_construct!");
}
// If reading permissable return property value
$getMatches = StringMethods::match($name, "^get([a-zA-Z0-9]+)\$");
if (sizeof($getMatches) > 0) {
$normalized = lcfirst($getMatches[0]);
$property = "_{$normalized}";
if (property_exists($this, $property)) {
$meta = $this->_inspector->getPropertyMeta($property);
if (empty($meta["@readwrite"]) && empty($meta["@read"])) {
throw $this->_getExceptionForWriteonly($normalized);
}
if (isset($this->{$property})) {
return $this->{$property};
}
return null;
}
}
// If writing is permissable set property value
$setMatches = StringMethods::match($name, "^set([a-zA-Z0-9]+)\$");
if (sizeof($setMatches > 0)) {
$normalized = lcfirst($setMatches[0]);
$property = "_{$normalized}";
if (property_exists($this, $property)) {
$meta = $this->_inspector->getPropertyMeta($property);
if (empty($meta["@readwrite"]) && empty($meta["@write"])) {
throw $this->_getExceptionForReadonly($normalized);
}
$this->{$property} = $arguments[0];
return $this;
}
}
// If property does not exist in a class thow exception
throw $this->_getExceptionForImplementation($name);
}
/**
* Begins by getting a list of columns and iterating over that list. For each column, we determine whether validation should occur.
* We then split the @validate metadata into a list of validation conditions. If a condition has arguments, we extract the arguments.
* We then run each validation method on the column data and generate error messages for those validation conditions that failed.
*
* @return type
* @throws Exception\Validation
*/
public function validate()
{
$this->_errors = array();
foreach ($this->columns as $column) {
if ($column["validate"]) {
$pattern = "#[a-z]+\\(([a-zA-Z0-9, ]+)\\)#";
$raw = $column["raw"];
$name = $column["name"];
$validators = $column["validate"];
$label = $column["label"];
$defined = $this->getValidators();
foreach ($validators as $validator) {
$function = $validator;
$arguments = array($this->{$raw});
$match = StringMethods::match($validator, $pattern);
if (count($match) > 0) {
$matches = StringMethods::split($match[0], ",\\s*");
$arguments = array_merge($arguments, $matches);
$offset = StringMethods::indexOf($validator, "(");
$function = substr($validator, 0, $offset);
}
if (!isset($defined[$function])) {
throw new Exception\Validation("The {$function} validator is not defined");
}
$template = $defined[$function];
if (!call_user_func_array(array($this, $template["handler"]), $arguments)) {
$replacements = array_merge(array($label ? $label : $raw), $arguments);
$message = $template["message"];
foreach ($replacements as $i => $replacement) {
$message = str_replace("{{$i}}", $replacement, $message);
}
if (!isset($this->_errors[$name])) {
$this->_errors[$name] = array();
}
$this->_errors[$name][] = $message;
}
}
}
}
return !sizeof($this->errors);
}
/**
* Returns an array of objects
* @return array|string Array of objects of \stdClass (success), Error Message (failure)
*/
protected function _getSiteMaps(&$gClient, $website, $opts = array())
{
try {
$webmaster = new Google_Service_Webmasters($gClient);
$sitemaps = $webmaster->sitemaps;
$response = $sitemaps->listSitemaps($website, $opts);
$response = $response->getSitemap();
$result = array();
foreach ($response as $r) {
$contents = $r->getContents();
$content = array();
foreach ($contents as $c) {
$content[] = array("type" => $c->type, "submitted" => $c->submitted, "indexed" => $c->indexed);
}
$result[] = array("path" => $r->path, "errors" => $r->errors, "pending" => $r->isPending, "type" => $r->type, "warnings" => $r->warnings, "lastDownloaded" => array_shift(StringMethods::match($r->lastDownloaded, "(.*)T")), "lastSubmitted" => array_shift(StringMethods::match($r->lastSubmitted, "(.*)T")), "contents" => $content);
}
$result = ArrayMethods::toObject($result);
} catch (\Exception $e) {
$result = $e->getMessage();
}
return $result;
}
/**
* Validate that a given field passes regular expression check
* @param string $field Field being validated
* @param mixed $value Value being validated
* @param array $parameters Regular expression to be matched
* @return bool
*/
protected function _validateMatch($field, $value, $parameters)
{
return StringMethods::match($value, $parameters[0]);
}
