This class is used when we need to return a standard object, but none of the current available standard objects
fit the role.
/**
* Get or update the given key inside current array. This method supports nested key access: 'level1.level2.level3'
*
* @param string|int|StringObject $key Array key Eg: 'level1.level2.level3'
* @param null|mixed $value If set, the value under current $key will be updated and not returned.
* @param bool $setOnlyIfDoesntExist Set the $value only in case if the $key doesn't exist.
*
* @return $this|mixed|StringObject The value of the given key.
*/
public function keyNested($key, $value = null, $setOnlyIfDoesntExist = false)
{
$key = StdObjectWrapper::toString($key);
// If key does not exist, set default $value and return it
if ($setOnlyIfDoesntExist && !$this->keyExistsNested($key)) {
$this->handleNestedValue($key, $value, true);
return $value;
} elseif (!$value && !$setOnlyIfDoesntExist && !$this->keyExistsNested($key)) {
// This means we are trying to get a value of nested key that does not exist
return null;
} else {
// Set new $value into given $key
if (!$setOnlyIfDoesntExist && !$this->isNull($value)) {
$this->handleNestedValue($key, $value, false);
return $this;
}
}
$array = $this->val();
// Get value for given $key
if (strpos($key, '.') !== false) {
$keys = explode('.', trim($key, '.'), 2);
if (!isset($array[$keys[0]])) {
$array[$keys[0]] = [];
}
$targetArray = new ArrayObject($array[$keys[0]]);
return $targetArray->keyNested($keys[1], $value, true);
}
return isset($array[$key]) ? $array[$key] : $value;
}
/**
* Checks if md5 string is valid
*
* @param String $md5
*
* @return Boolean
*/
private static function isMd5($md5)
{
if (!self::isString($md5) && !self::isStringObject($md5)) {
return false;
}
$md5 = StdObjectWrapper::toString($md5);
return !empty($md5) && preg_match('/^[a-f0-9]{32}$/', $md5);
}
/**
* Set method to be called on handler.<br />
* If not set, default method will be called:
* <code>handle(Event $event)</code>
*
* @param string $method Method to call on handler
*
* @throws EventManagerException
* @return $this
*/
public function method($method)
{
if (!$this->isString($method) && !$this->isStringObject($method)) {
throw new EventManagerException(EventManagerException::MSG_INVALID_ARG, ['$method', 'string|StringObject']);
}
$this->method = StdObjectWrapper::toString($method);
return $this;
}
/**
* Parse given Yaml resource and build array
* This method must support file paths (string or StringObject) and FileObject
*
* @throws SymfonyYamlException
* @return string
*/
private function parseResource()
{
if ($this->isArray($this->resource)) {
return StdObjectWrapper::toArray($this->resource);
} elseif ($this->isString($this->resource)) {
return Yaml::parse($this->resource);
} elseif ($this->isInstanceOf($this->resource, 'Webiny\\Component\\Config\\ConfigObject')) {
return $this->resource->toArray();
}
throw new SymfonyYamlException(SymfonyYamlException::UNABLE_TO_PARSE, [gettype($this->resource)]);
}
/**
* Base constructor.
*
* @param string|array|ArrayObject $content Json content.
* @param array $headers Headers to attach to the response.
* @param bool $prettyPrint Should we use JSON_PRETTY_PRINT to nicely format the output.
*/
public function __construct($content, $headers = [], $prettyPrint = false)
{
if (StdObjectWrapper::isArrayObject($content)) {
$content = $this->jsonEncode($content->val(), $prettyPrint ? JSON_PRETTY_PRINT : 0);
} else {
if ($this->isArray($content) || $this->isObject($content)) {
$content = $this->jsonEncode($content, $prettyPrint ? JSON_PRETTY_PRINT : 0);
}
}
parent::__construct($content, 200, $headers);
$this->setContentType('application/json');
}
public function __construct($entityClass, $entityCollection, $conditions, $order, $limit, $offset)
{
// Convert boolean strings to boolean
foreach ($conditions as &$condition) {
if (is_scalar($condition) && (strtolower($condition) === 'true' || strtolower($condition) === 'false')) {
$condition = StdObjectWrapper::toBool($condition);
}
}
$this->entityClass = $entityClass;
$this->collectionName = $entityCollection;
$this->conditions = $conditions;
$this->limit = $limit;
$this->offset = $offset;
$this->data = Entity::getInstance()->getDatabase()->find($entityCollection, $conditions, $order, $limit, $offset);
}
protected function validate(&$value)
{
if ($this->isNull($value)) {
return $this;
}
if (!$this->isArray($value) && !$this->isArrayObject($value)) {
$this->expected('array or ArrayObject', gettype($value));
}
$value = StdObjectWrapper::toArray($value);
if (!array_key_exists('lat', $value) || !array_key_exists('lng', $value)) {
$ex = new ValidationException(ValidationException::VALIDATION_FAILED);
$ex->addError($this->attribute, 'GeoPointAttribute value must contain `lat` and `lng`');
throw $ex;
}
}
/**
* Checks if $key exists in current array as index. If it exists, true is returned.
* If the $key doesn't exist, $default is returned.
* This method supports nested keys access: 'level1.level2.level3'
*
* @param string|StringObject $key Array key. Eg: 'level1.level2.level3'
* @param mixed $default If key is not found, $default is returned.
*
* @return bool|mixed True is returned if the key exists, otherwise $default is returned.
*/
public function keyExistsNested($key, $default = false)
{
$key = StdObjectWrapper::toString($key);
if (strpos($key, '.') !== false) {
$keys = explode('.', trim($key, '.'), 2);
if (!isset($this->val()[$keys[0]])) {
return $default;
}
$sourceArray = new ArrayObject($this->val()[$keys[0]]);
return $sourceArray->keyExistsNested($keys[1], $default);
}
if (array_key_exists($key, $this->val())) {
return true;
}
return $default;
}
public function setInvalidAttributes($attributes)
{
$this->invalidAttributes = StdObjectWrapper::toArray($attributes);
return $this;
}
/**
* Build internal object data using given $config
*
* @param array|ArrayObject $config
*/
private function buildInternalData($config)
{
$this->data = $this->arr();
$array = StdObjectWrapper::toArray($config);
foreach ($array as $key => $value) {
if ($this->isArray($value)) {
$this->data->key($key, new static($value, false));
} else {
$this->data->key($key, $value, true);
}
}
}
/**
* Set multiple headers
*
* @param array|ArrayObject $headers
*
* @return $this
*/
public function setHeaders($headers)
{
$headers = StdObjectWrapper::toArray($headers);
$this->message['headers'] = $headers;
return $this;
}
/**
* Get config data as array
*
* @throws ConfigException
* @return array Parsed resource data array
*/
public final function getArray()
{
$res = $this->getArrayInternal();
if (!$this->isArray($res) && !$this->isArrayObject($res)) {
$errorMessage = 'AbstractDriver method _getArray() must return array or ArrayObject.';
$errorMessage .= ' Make sure you have provided a valid config file path with file extension.';
throw new ConfigException($errorMessage);
}
return StdObjectWrapper::toArray($res);
}
/**
* Set url query param.
*
* @param StringObject|ArrayObject|string|array $query Query params.
* @param bool $append Do you want to append or overwrite current query param.
* In case when you are appending values, the values from $query,
* that already exist in the current query, will be overwritten
* by the ones inside the $query.
*
* @throws UrlObjectException
* @return $this
*/
public function setQuery($query, $append = false)
{
if ($this->isStdObject($query)) {
$query = $query->val();
}
if ($append && $this->query != '') {
if ($this->isString($this->query)) {
$currentQuery = new StringObject($this->query);
$currentQuery = $currentQuery->parseString();
} else {
$currentQuery = new ArrayObject($this->query);
}
if ($this->isStdObject($query)) {
if (StdObjectWrapper::isArrayObject($append)) {
$query = $query->val();
} else {
if (StdObjectWrapper::isStringObject($query)) {
$query = $query->parseString()->val();
} else {
throw new UrlObjectException(UrlObjectException::MSG_INVALID_ARG, ['$query', 'StringObject|ArrayObject|string|array']);
}
}
} else {
if ($this->isString($query)) {
$query = new StringObject($query);
$query = $query->parseString()->val();
}
}
$currentQuery->merge($query);
$query = $currentQuery->val();
}
$this->query = $query;
$this->rebuildUrl();
return $this;
}
/**
* Set related entity class for this attribute<br>
* You can either use absolute namespace path or <b>App.Component.Entity</b> notation:<br><br>
*
* <b>'Cms.Content.PageEntity'</b> will be translated to: <b>'\WebinyPlatform\Apps\Cms\Components\Content\Entities\PageEntity'</b>
*
* @param string $entityClass
*
* @return $this
*/
public function setEntity($entityClass)
{
$entityClass = $this->str($entityClass);
if ($entityClass->contains('.')) {
$parts = $entityClass->explode('.');
$entityClass = '\\WebinyPlatform\\Apps\\' . $parts[0] . '\\Components\\' . $parts[1] . '\\Entities\\' . $parts[2];
}
$this->entityClass = StdObjectWrapper::toString($entityClass);
return $this;
}
/**
* Check if $instance is a UrlObject.
*
* @param mixed $instance
*
* @return bool
*/
protected static function isUrlObject($instance)
{
return StdObjectWrapper::isUrlObject($instance);
}
public function toArray($params = [])
{
return $this->processToArrayValue(StdObjectWrapper::toBool(parent::toArray($params)));
}
private function normalizeData($data)
{
if ($this->isArray($data) || $this->isArrayObject($data)) {
return StdObjectWrapper::toArray($data);
}
return $data;
}
/**
* Checks if the current string ends with the given $string.
*
* @param string|StringObject $string String to check.
*
* @return bool If current string ends with $string, true is returned, otherwise false.
*/
public function endsWith($string)
{
$string = StdObjectWrapper::toString($string);
// calculate the end position
$length = strlen($string);
$endString = substr($this->val(), -$length);
if ($string == $endString) {
return true;
}
return false;
}
/**
* Execute callback from MatchedRoute and return result.<br>
* Required callback structure is:
* <code>
* Callback:
* Class: \Your\Class
* Method: handle
* Static: true // (Optional, "false" by default)
*
*</code>
* @param MatchedRoute $route
*
* @return mixed
*
* @throws RouterException
*/
public function execute(MatchedRoute $route)
{
$callback = $route->getCallback();
if ($this->isString($callback)) {
throw new RouterException(RouterException::STRING_CALLBACK_NOT_PARSABLE);
}
$callback = $this->arr($callback);
$handlerClass = $callback->key('Class', false, true);
$handlerMethod = $callback->key('Method', false, true);
$staticMethod = StdObjectWrapper::toBool($callback->key('Static', false, true));
if (!class_exists($handlerClass)) {
throw new RouterException(RouterException::CALLBACK_CLASS_NOT_FOUND, [$handlerClass]);
}
if (!method_exists($handlerClass, $handlerMethod)) {
throw new RouterException(RouterException::CALLBACK_CLASS_METHOD_NOT_FOUND, [$handlerMethod, $handlerClass]);
}
if ($staticMethod) {
return forward_static_call_array([$handlerClass, $handlerMethod], $route->getParams());
}
return call_user_func_array([new $handlerClass(), $handlerMethod], $route->getParams());
}
public function getToArrayValue()
{
return StdObjectWrapper::toBool(parent::getToArrayValue());
}
/**
* Get Yaml value as array
*
* @throws YamlException
* @return array
*/
public function getArray()
{
$res = $this->driverInstance->getArray();
if (!$this->isArray($res) && !$this->isArrayObject($res)) {
throw new YamlException('YamlInterface method getArray() must return an array or ArrayObject.');
}
return StdObjectWrapper::toArray($res);
}
/**
* Get the first element in the array.
* If the element is array, ArrayObject is returned, else StringObject is returned.
*
* @return StringObject|ArrayObject|StdObjectWrapper The first element in the array.
*/
public function first()
{
$arr = $this->val();
$first = reset($arr);
return StdObjectWrapper::returnStdObject($first);
}
