public function transform(array $data)
{
$code = isset($data[$this->httpCodeKey]) ? $data[$this->httpCodeKey] : 200;
$arrayResponse = ArrayUtils::fromObject($data);
$response = new JsonResponse($arrayResponse, $code);
return $response;
}
public function handleEntityUpdate(AbstractEntity $entity, array $allowedProperties, array $data)
{
$data = ArrayUtils::filterKeys($data, $allowedProperties);
$repository = $this->knit->getRepository($entity->__getClass());
try {
$entity->updateWithData($data);
$repository->save($entity);
} catch (DataValidationFailedException $e) {
$errors = array();
foreach ($e->getErrors() as $error) {
$errors[$error->getProperty()] = $error->getFailedValidators();
}
return array($this->httpCodeKey => 400, 'errors' => $errors);
}
return array();
}
/**
* Create an article.
*
* Returns path to the created markdown file.
*
* @param string $title Title of the article.
* @param string $slug [optional] Slug of the article. If ommitted, it will be built based on the title.
* @param string $image [optional] Path to cover image, relative to the web root folder.
*
* @return string
*/
public function create($title, $slug = null, $image = null)
{
$slug = $slug ? StringUtils::urlFriendly($slug) : StringUtils::urlFriendly($title);
$articles = $this->reader->load();
// check if maybe there already is such article
if (ArrayUtils::search($articles, 'slug', $slug) !== false) {
throw new NotUniqueException('There already is a blog article with a slug "' . $slug . '".');
}
// create a markdown post
$markdown = $title . NL . '==========' . NL . date('Y-m-d') . NL . ($image ? '' . NL : '') . NL;
$markdownFile = $this->articlesDir . $slug . '.md';
// create the articles directory if doesn't exist
$this->filesystem->dumpFile($markdownFile, $markdown);
// add to articles array
array_unshift($articles, array('slug' => $slug, 'title' => $title));
$this->writer->write($this->dataFile, $articles);
return $markdownFile;
}
/**
* When the found controller method wants to have the request injected,
* this method will do it.
*
* @param ControllerWillRespond $event Event triggered before execution of controller.
*/
public function injectRequest(ControllerWillRespond $event)
{
$route = $this->router->getRoute($event->getControllerName());
// find the method's meta data
$methods = $route->getMethods();
$i = ArrayUtils::search($methods, 'method', $event->getMethod());
if ($i === false) {
return;
}
$method = $methods[$i];
$arguments = $event->getArguments();
foreach ($method['params'] as $i => $param) {
if ($param['class'] && Debugger::isExtending($param['class'], Request::class, true) && !$arguments[$i] instanceof Request) {
$arguments[$i] = $this->request;
}
}
$event->setArguments($arguments);
}
/**
* Returns list of available processes
*
* @return array
*/
public function getAvailableProcesses()
{
$known_processes = array();
foreach ($this->getAllProcessInfo() as $process) {
$known_processes[ArrayUtils::get($process, 'group')] = ArrayUtils::get($process, 'name');
}
return $known_processes;
}
/**
* Returns a string containing JavaScript code that will log all the arguments into browser's JavaScript console.
*
* Attempts to convert all objects into arrays.
*
* There is a shortcut alias function `\MD\console_string_dump()`.
*
* @param mixed $variable1 Variable to be dumped.
* @param mixed $variable2 Another variable to be dumped.
* @param mixed $variable3 Another variable to be dumped.
* @param ...
* @return string
*/
public static function consoleStringDump()
{
$arguments = func_get_args();
$output = '(function(w,u) {';
$output .= 'if(w.console===u)return;';
foreach ($arguments as $variable) {
$dump = null;
if (is_object($variable)) {
$dump = json_encode(ArrayUtils::fromObject($variable));
} elseif (is_bool($variable)) {
$dump = '"(bool) ' . ($variable ? 'true' : 'false') . '"';
} else {
$dump = json_encode($variable);
}
$output .= 'w.console.log(' . $dump . ');';
}
$output .= '})(window);';
return $output;
}
/**
* Generates a URL for this route, using the given parameters.
*
* If some parameters aren't in the pattern, then they will be attached as a query string.
*
* @param array $params Route parameters.
* @param string $host [optional] Host to prefix the URL with. Should also include the protocol, e.g. 'http://domain.com'.
* Default: null - no host included.
* @return string
*/
public function generateUrl(array $params = array(), $host = null)
{
if ($this->isPrivate()) {
throw new \RuntimeException('Route "' . $this->getName() . '" is set to private, so it is not reachable via URL, therefore it cannot have a URL generated.');
}
$routeName = $this->getName();
$url = preg_replace_callback('/(\\{([\\w:]+)\\})(\\?)?/is', function ($matches) use(&$params, $routeName) {
$constraints = explode(':', $matches[2]);
$name = array_shift($constraints);
$optional = isset($matches[3]) && $matches[3] === '?';
if (!isset($params[$name])) {
if (!$optional) {
throw new RouteParameterNotFoundException('Could not find parameter "' . $name . '" for route "' . $routeName . '".');
} else {
return '';
}
}
$param = urlencode($params[$name]);
unset($params[$name]);
/** @todo Should also check the constraints before injecting the item. */
return $param;
}, $this->getUrlPattern());
// remove all optional characters from the route
$url = preg_replace('/(\\/\\/\\?)/is', '/', $url);
// two slashes followed by a ? (ie. //? ) change to a single slash (ie. /).
$url = str_replace('?', '', $url);
// remove any other ? marks
if (!empty($params)) {
$url .= '?' . ArrayUtils::toQueryString($params);
}
if ($host && !empty($host)) {
$url = rtrim($host, '/') . '/' . ltrim($url, '/');
}
return $url;
}
/**
* Returns code status text
*
* @param int $code
* @param string $default
*
* @return string
*/
public static function getText($code, $default = '')
{
return ArrayUtils::get(self::$statusTexts, $code, $default);
}
/**
* @dataProvider collectionProvider
*/
public function testResetKeys($collection)
{
$this->assertTrue(ArrayUtils::isCollection(ObjectUtils::resetKeys($collection)));
$collectionNamed = ObjectUtils::keyExplode($collection, 'name');
$this->assertTrue(ArrayUtils::isCollection(ObjectUtils::resetKeys($collectionNamed)), 'Failed to assert that MD\\Foundation\\Utils\\Object::resetKeys() returns a collection.');
}
/**
* Transforms the whole data to JSON format.
*
* @return string
*/
public function toJson()
{
return json_encode(ArrayUtils::fromObject($this->data));
}
/**
* Gets an article based on slug.
*
* @param string $slug Slug of the article to get.
*
* @return Article
*/
public function getArticle($slug)
{
$data = $this->load();
$i = ArrayUtils::search($data, 'slug', $slug);
if ($i === false) {
throw new NotFoundException('Could not find blog article with slug "' . $slug . '".');
}
return $this->readArticle($data[$i]['slug']);
}
/**
* Returns connection config if defined
*
* @param string $name
*
* @return array|null
*/
public function getConfiguration($name)
{
return ArrayUtils::get($this->configs, $name, null);
}
public function testOnly()
{
$input = array('name' => 'John', 'surname' => 'Doe', 'age' => 30);
$expected = array('name' => 'John', 'surname' => 'Doe');
$result = ArrayUtils::only($input, array('name', 'surname'));
$this->assertSame($expected, $result);
}
/**
* Resets keys of an array containing a collection of objects to numerical values starting with `0`.
*
* @param array|object $objects Collection of objects - either an array or a collection object that implements `toArray` method.
* @return array Resetted array.
*
* @throws InvalidArgumentException When the `$objects` argument is not an array or cannot be converted to an array.
*/
public static function resetKeys($objects)
{
// convert to array, for example for Doctrine collections
if (is_object($objects) && method_exists($objects, 'toArray')) {
$objects = $objects->toArray();
}
if (!is_array($objects)) {
throw new InvalidArgumentException('array or object convertible to array', $objects);
}
return ArrayUtils::resetKeys($objects);
}
/**
* Expands GLOB resource patterns.
*
* @param string $resource Resource name.
* @param string $type Type of the resource.
* @return array
*/
public function expand($resource, $type)
{
list($moduleName, $subDir, $filePattern) = $this->parseResourceName($resource);
$resourceLocation = $moduleName . ':' . $subDir . ':';
// read from application dir
$appDir = rtrim($this->_application->getApplicationDir(), DS) . DS . 'Resources' . DS;
// if a module name was specified then point to a subfolder with the module name
if (!empty($moduleName)) {
// check for module existence in the first place
if (!$this->_application->hasModule($moduleName)) {
throw new ResourceNotFoundException('There is no module "' . $moduleName . '" registered, so cannot find its resource.');
}
$appDir = $appDir . $moduleName . DS;
}
$appDir = $this->buildResourcePath($appDir, $type, $subDir, '');
$appFiles = FilesystemUtils::glob($appDir . $filePattern, FilesystemUtils::GLOB_ROOTFIRST | GLOB_BRACE);
$resources = array();
foreach ($appFiles as $file) {
$resources[] = $resourceLocation . substr($file, mb_strlen($appDir));
}
// now take care of the module dir
if ($moduleName) {
$module = $this->_application->getModule($moduleName);
$moduleDir = rtrim($module->getModuleDir(), DS) . DS . 'Resources' . DS;
$moduleDir = $this->buildResourcePath($moduleDir, $type, $subDir, '');
$moduleFiles = FilesystemUtils::glob($moduleDir . $filePattern, GLOB_BRACE);
foreach ($moduleFiles as $file) {
$resources[] = $resourceLocation . substr($file, mb_strlen($moduleDir));
}
}
$resources = array_unique($resources);
return ArrayUtils::sortPaths($resources, true);
}
/**
* Sort the items based on `orderBy` and `orderDir` parameters.
*
* @param array $items Items to be sorted.
* @param array $params Query params.
*
* @return array
*/
protected function sort(array $items, array $params)
{
if (is_array($params['orderBy'])) {
foreach ($params['orderBy'] as $property => $orderDir) {
if (is_string($orderDir)) {
$property = $orderDir;
$orderDir = Knit::ORDER_ASC;
}
$items = ArrayUtils::multiSort($items, $property, $orderDir === Knit::ORDER_DESC);
// memory sorting only supports one level sorting
break;
}
return $items;
}
$orderDir = isset($params['orderDir']) ? $params['orderDir'] : Knit::ORDER_ASC;
return ArrayUtils::multiSort($items, $params['orderBy'], $orderDir === Knit::ORDER_DESC);
}
/**
* Extended `glob()` functionality that supports double star `**` (globstar) wildcard.
*
* PHP's `glob()` implementation doesn't allow for `**` wildcard. In Bash 4 it can be enabled with `globstar` setting.
*
* In case the `**` wildcard is not used in the pattern then this method just calls PHP's `glob()`.
*
* For full documentation see PHP's [`glob()` documentation](http://php.net/manual/en/function.glob.php).
*
* It's worth noting that if you want to find files inside current directory and their subdirectories,
* then you have to use a `GLOB_BRACE` flag and pattern, e.g.:
*
* echo \MD\Foundation\Utils\FilesystemUtils::glob('{,** /}*.js', GLOB_BRACE); // note: remove space between * and /
* // -> array(
* // 'main.js',
* // 'dir/script.js',
* // 'dir/more/scripts.js'
* // );
*
* Implementation of this convention varies between libs in various languages and `MD\Foundation` sticks
* with what [Bash manual states](http://www.gnu.org/software/bash/manual/bashref.html#Pattern-Matching).
* More about this is explained in [#2](https://github.com/michaldudek/Foundation/issues/2).
*
* This function also supports its own implementation of `GLOB_BRACE` flag on systems that do not support it
* (e.g. Alpine Linux, popular base for Docker containers). Because it's impossible to detect if that flag was
* passed or not (as it has `null` or `0` value), on such systems the function assumes that yes, this flag was
* passed if there are any `{}` braces used in the pattern. This implementation might not be so fast as a system
* implementation, so use with caution or switch to "fuller" distro.
*
* Additionally it provides sorting option to the results, which you can pass along with
* other flags. Constants `FilesystemUtils::GLOB_ROOTFIRST` and `FilesystemUtils::GLOB_CHILDFIRST`
* sort the results either as "root first" where files in a directory are listed before directories and
* subdirectories, or "child first" where subdirectories are listed before files.
*
* @param string $pattern The pattern. Supports `**` wildcard.
* @param int $flags [optional] `glob()` flags. See `glob()`'s documentation. Default: `0`.
* @return array|bool
*/
public static function glob($pattern, $flags = 0)
{
// turn off custom flags
$globFlags = ($flags | static::GLOB_CHILDFIRST | static::GLOB_ROOTFIRST) ^ (static::GLOB_CHILDFIRST | static::GLOB_ROOTFIRST);
// our custom implementation will be expanding some patterns (namely globstar and braces) so we gather them all
$patterns = array($pattern);
// expand GLOB_BRACE if it's not defined on the system (e.g. Alpine Linux)
// let's assume that it's passed always in such cases (most common usage)
// and keeping the original pattern will make us safe to detect the desired files with {} in name anyway
if (!defined('GLOB_BRACE') || !GLOB_BRACE) {
$patterns = array_merge($patterns, self::globBraceExpand($patterns));
}
// expand globstar if added
if (stripos($pattern, '**') !== false) {
$patterns = array_merge($patterns, self::globStarExpand($patterns, $globFlags));
}
// finally when all patterns expanded, just rerun them and merge results
$files = array();
foreach ($patterns as $pat) {
$files = array_merge($files, glob($pat, $globFlags));
}
// fix some paths as they might have gotten double // due to not-perfect pattern expansion
$files = array_map(function ($file) {
return str_replace('//', '/', $file);
}, $files);
// make sure no repetitions from all the patterns provided
$files = array_unique($files);
// sort by root first?
if ($flags & static::GLOB_ROOTFIRST) {
$files = ArrayUtils::sortPaths($files, true);
} else {
if ($flags & static::GLOB_CHILDFIRST) {
$files = ArrayUtils::sortPaths($files, false);
} elseif (!($flags & GLOB_NOSORT)) {
// default sort order is alphabetically
sort($files);
}
}
return $files;
}
/**
* Returns concrete factory for given response type.
*
* @param string $type
*
* @return ConcreteFactoryInterface
*/
protected function get($type)
{
return ArrayUtils::get($this->factories, $type, null);
}
/**
* Constructor.
*
* @param array $config Connection config.
* @param CriteriaParser $criteriaParser Knit criteria parser for MongoDB.
* @param LoggerInterface|null $logger [optional] Logger.
*
* @SuppressWarnings(PHPMD.CyclomaticComplexity,PHPMD.NPathComplexity)
*/
public function __construct(array $config, CriteriaParser $criteriaParser, LoggerInterface $logger = null)
{
// check for all required info
if (!ArrayUtils::checkValues($config, ['hostname', 'database'])) {
throw new \InvalidArgumentException('Invalid config passed to ' . __CLASS__ . '.');
}
$this->criteriaParser = $criteriaParser;
$this->logger = $logger ? $logger : new NullLogger();
try {
// define MongoClient options
$options = ['db' => $config['database'], 'connect' => true];
if (ArrayUtils::checkValues($config, ['username', 'password'])) {
$options['username'] = $config['username'];
$options['password'] = $config['password'];
}
if (isset($config['replica_set'])) {
$options['replicaSet'] = $config['replica_set'];
}
// define the DSN or connection definition string
$dsn = 'mongodb://' . $config['hostname'] . (isset($config['port']) && $config['port'] ? ':' . $config['port'] : '');
// also add any additional hosts
if (isset($config['hosts'])) {
if (!is_array($config['hosts'])) {
throw new \InvalidArgumentException(__CLASS__ . ' config option "hosts" must be an array of hosts.');
}
foreach ($config['hosts'] as $host) {
if (!ArrayUtils::checkValues($host, ['hostname'])) {
throw new \InvalidArgumentException(__CLASS__ . ' config option "hosts" must be an array of array hosts definitions' . ' with at least "hostname" key.');
}
$dsn .= ',' . $host['hostname'] . (isset($host['port']) && $host['port'] ? ':' . $host['port'] : '');
}
}
$this->dsn = $dsn;
$this->options = $options;
$this->databaseName = $config['database'];
} catch (MongoException $e) {
throw new StoreQueryErrorException($e->getMessage(), $e->getCode(), $e);
}
}
/**
* Extends the config with the given config.
*
* @param Config $config Config to read from.
* @return bool
*/
public function extend(Config $config)
{
$this->config = ArrayUtils::merge($this->config, $config->getNamespace());
$this->loadedFiles = array_merge($this->loadedFiles, $config->getLoadedFiles());
return true;
}
