Exemple #1
0
 private function format($text = '', $parameters = array())
 {
     if (!Arrays::is($parameters) && 'NONE' == $parameters) {
         return $text;
     }
     if (!Arrays::is($parameters) && isset($this->styles[$parameters])) {
         $parameters = $this->styles[$parameters];
     }
     $codes = array();
     $fg = isAke($parameters, 'fg', null);
     $bg = isAke($parameters, 'bg', null);
     if (!empty($fg)) {
         $codes[] = $this->foreground[$fg];
     }
     if (!empty($bg)) {
         $codes[] = $this->background[$bg];
     }
     foreach ($this->options as $option => $value) {
         $paramOpt = isAke($parameters, $option, null);
         if (!empty($paramOpt)) {
             $codes[] = $value;
         }
     }
     return "[" . implode(';', $codes) . 'm' . $text . "";
 }
Exemple #2
0
 public function orderBy($tab, $fieldOrder, $orderDirection = 'ASC')
 {
     $sortFunc = function ($key, $direction) {
         return function ($a, $b) use($key, $direction) {
             if ('ASC' == $direction) {
                 return $a[$key] > $b[$key];
             } else {
                 return $a[$key] < $b[$key];
             }
         };
     };
     if (Arrays::is($fieldOrder) && !Arrays::is($orderDirection)) {
         $t = array();
         foreach ($fieldOrder as $tmpField) {
             array_push($t, $orderDirection);
         }
         $orderDirection = $t;
     }
     if (!Arrays::is($fieldOrder) && Arrays::is($orderDirection)) {
         $orderDirection = Arrays::first($orderDirection);
     }
     if (Arrays::is($fieldOrder) && Arrays::is($orderDirection)) {
         for ($i = 0; $i < count($fieldOrder); $i++) {
             usort($tab, $sortFunc($fieldOrder[$i], $orderDirection[$i]));
         }
     } else {
         usort($tab, $sortFunc($fieldOrder, $orderDirection));
     }
     return $tab;
 }
Exemple #3
0
 public function keys($pattern)
 {
     $keys = $this->session->getKeys();
     if (!empty($keys)) {
         $seg = isAke($keys, sha1($pattern));
         if (!empty($seg)) {
             return $seg;
         }
     }
     $this->call('keys', array("pattern" => $pattern));
     $tab = json_decode($this->response, true);
     $res = isAke($tab, 'message');
     $collection = array();
     if (Arrays::is($res)) {
         if (count($res)) {
             foreach ($res as $row) {
                 array_push($collection, $row);
             }
         }
     }
     if (empty($keys)) {
         $keys = array();
     }
     $keys[sha1($pattern)] = $collection;
     $this->session->setKeys($keys);
     return $collection;
 }
Exemple #4
0
 public function __call($method, $args)
 {
     if (true === $this->__has($method)) {
         return $this->__fire($method, $args);
     }
     $reverse = strrev($method);
     $last = $reverse[0];
     if ('s' == $last) {
         if (!count($args)) {
             return isAke($this->values, $method);
         } else {
             $this->values[$method] = !Arrays::is($this->values[$method]) ? array() : $this->values[$method];
             foreach ($args as $arg) {
                 array_push($this->values[$method], $arg);
             }
         }
         return $this;
     } else {
         $method .= 's';
         if (!count($args)) {
             $val = isAke($this->values, $method);
             return count($val) ? Arrays::first($val) : null;
         } else {
             $this->values[$method] = !Arrays::is($this->values[$method]) ? array() : $this->values[$method];
             foreach ($args as $arg) {
                 array_push($this->values[$method], $arg);
             }
         }
         return $this;
     }
 }
Exemple #5
0
 public static function send($arguments = array())
 {
     $response = static::request('messages/send', $arguments);
     if (false !== $response && Arrays::is($response)) {
         $response = Arrays::first($response);
         return $response['status'] == 'sent' ? true : $response['status'];
     }
     return false;
 }
Exemple #6
0
 public function getHeader()
 {
     $this->rewind();
     $current = $this->current();
     if (Arrays::is($current)) {
         return $current;
     }
     return array();
 }
Exemple #7
0
 public function make(array $array)
 {
     $return = array();
     foreach ($array as $k => $v) {
         if (Arrays::is($v)) {
             $o = new self();
             $return[$k] = $o->populate($v);
         } else {
             $return[$k] = $v;
         }
     }
     return $return;
 }
Exemple #8
0
 public static function clean($data)
 {
     if (Arrays::is($data)) {
         foreach ($data as $key => $value) {
             unset($data[$key]);
             $data[static::clean($key)] = static::clean($value);
         }
     } else {
         if (ini_get('magic_quotes_gpc')) {
             $data = stripslashes($data);
         } else {
             $data = htmlspecialchars($data, ENT_QUOTES, 'UTF-8');
         }
     }
     return $data;
 }
Exemple #9
0
 /**
  * Add file to the archive
  *
  * @param array/string $files
  * @param string $string
  * @return bool
  */
 public function add($files, $string = false)
 {
     if (true === $this->_enabled) {
         if (Arrays::is($files)) {
             foreach ($files as $file) {
                 $this->_addFile((string) $file);
             }
         } else {
             if (!empty($string) && is_string($string)) {
                 return $this->_zip->addFromString($files, $string);
             } else {
                 return $this->_addFile($files);
             }
         }
     }
     return false;
 }
Exemple #10
0
 public function keys($pattern)
 {
     $collection = $this->data($pattern);
     if (!Arrays::is($collection)) {
         $oldPattern = $pattern;
         $pattern .= '*#*';
         $pattern = repl('**', '*', $pattern);
         $files = $this->glob($this->dir . DS . $pattern);
         $collection = array();
         if (count($files)) {
             foreach ($files as $row) {
                 array_push($collection, $row);
             }
         }
         $this->setData($oldPattern, $collection);
     }
     return $collection;
 }
Exemple #11
0
 private static function dispatch()
 {
     $uri = str_replace(Config::get('application.base_uri'), '', isAke($_SERVER, 'REQUEST_URI', '/'));
     $method = strtolower(isAke($_SERVER, 'REQUEST_METHOD', 'get'));
     $routes = (include CONFIG_PATH . DS . 'routes.php');
     if (!empty($routes)) {
         foreach ($routes as $route) {
             $methodRoute = !isset($route->method) ? 'get' : strtolower($route->method);
             if ($route->path == $uri && $methodRoute == $method) {
                 return $route;
             }
             $match = static::match($route->path, $uri);
             if (false !== $match && $methodRoute == $method) {
                 if (!empty($match)) {
                     $args = $route->args;
                     if (Arrays::is($args)) {
                         if (count($match) == count($args)) {
                             $continue = false;
                             $i = 1;
                             foreach ($args as $key => $closure) {
                                 $val = $closure($match[$i]);
                                 if (false === $val) {
                                     $continue = true;
                                     break;
                                 }
                                 $_REQUEST[$key] = $val;
                                 $i++;
                             }
                             if (true === $continue) {
                                 continue;
                             }
                         }
                     }
                 }
                 return $route;
             }
         }
     }
     return static::route(['controller' => 'static', 'action' => 'is404']);
 }
Exemple #12
0
 public static function configs($entity, $key, $value = null, $cb = null)
 {
     if (!strlen($entity)) {
         throw new Exception("An entity must be provided to use this method.");
     }
     if (!Arrays::exists($entity, static::$configs)) {
         self::$configs[$entity] = array();
     }
     if (empty($value)) {
         if (!strlen($key)) {
             throw new Exception("A key must be provided to use this method.");
         }
         return isAke(self::$configs[$entity], $key, null);
     }
     if (!strlen($key)) {
         throw new Exception("A key must be provided to use this method.");
     }
     $reverse = strrev($key);
     $last = $reverse[0];
     if ('s' == $last) {
         self::$configs[$entity][$key] = $value;
     } else {
         if (!Arrays::is(self::$configs[$entity][$key . 's'])) {
             self::$configs[$entity][$key . 's'] = array();
         }
         array_push(self::$configs[$entity][$key . 's'], $value);
     }
     return !is_callable($cb) ? true : $cb();
 }
Exemple #13
0
 public static function mime($extension, $default = 'application/octet-stream')
 {
     Config::load('mimes');
     $mimes = null !== config::get('mimes') ? config::get('mimes') : [];
     if (!Arrays::exists($extension, $mimes)) {
         return $default;
     }
     return Arrays::is($mimes[$extension]) ? Arrays::first($mimes[$extension]) : $mimes[$extension];
 }
Exemple #14
0
 /**
  * Check if the array is a multidimensional array
  *
  * @param  Array   $array The array to check
  * @return boolean
  */
 protected function isMulti(array $array)
 {
     $first = array_shift($array);
     return Arrays::is($first);
 }
Exemple #15
0
 /**
  * Merges any number of arrays of any dimensions, the later overwriting
  * previous keys, unless the key is numeric, in whitch case, duplicated
  * values will not be added.
  *
  * The arrays to be merged are passed as arguments to the function.
  *
  * @return array Resulting array, once all have been merged
  */
 public function arrayMergeRecursiveReplace()
 {
     // Holds all the arrays passed
     $params = func_get_args();
     // First array is used as the base, everything else overwrites on it
     $return = array_shift($params);
     // Merge all arrays on the first array
     foreach ($params as $array) {
         foreach ($array as $key => $value) {
             // Numeric keyed values are added (unless already there)
             if (is_numeric($key) && !in_array($value, $return)) {
                 if (Arrays::is($value)) {
                     $return[] = $this->arrayMergeRecursiveReplace($return[$key], $value);
                 } else {
                     $return[] = $value;
                 }
                 // String keyed values are replaced
             } else {
                 if (isset($return[$key]) && Arrays::is($value) && Arrays::is($return[$key])) {
                     $return[$key] = $this->arrayMergeRecursiveReplace($return[$key], $value);
                 } else {
                     $return[$key] = $value;
                 }
             }
         }
     }
     return $return;
 }
Exemple #16
0
 /**
  *	Remove an index of the keys in a collection. To set values to descending order,
  *	you must pass values of either -1, false, 'desc', or 'DESC', else they will be
  *	set to 1 (ASC).
  *
  *	@param	string	$collection		the collection name
  *	@param	array	$keys			an associative array of keys, array(field => direction)
  *	@usage	$mongodb->removeIndex($collection, array('first_name' => 'ASC', 'last_name' => -1));
  */
 public function removeIndex($collection = '', $keys = array())
 {
     if (empty($collection)) {
         throw new Exception("No Mongo collection specified to remove an index from");
     }
     if (empty($keys) || !Arrays::is($keys)) {
         throw new Exception("Index could not be removed from MongoDB Collection because no keys were specified");
     }
     if ($this->db->{$collection}->deleteIndex($keys) == true) {
         $this->_clear();
         return $this;
     } else {
         throw new Exception("An error occured when trying to remove an index from MongoDB Collection");
     }
 }
Exemple #17
0
 public static function mergeOptions(array $array1, $array2 = null)
 {
     if (Arrays::is($array2)) {
         foreach ($array2 as $key => $val) {
             if (Arrays::is($array2[$key])) {
                 $array1[$key] = Arrays::exists($key, $array1) && Arrays::isArray($array1[$key]) ? static::mergeOptions($array1[$key], $array2[$key]) : $array2[$key];
             } else {
                 $array1[$key] = $val;
             }
         }
     }
     return $array1;
 }
Exemple #18
0
 public function order($fieldOrder, $orderDirection = 'ASC', $results = array())
 {
     $res = count($results) ? $results : $this->results;
     if (empty($res)) {
         return $this;
     }
     $sortFunc = function ($key, $direction) {
         return function ($a, $b) use($key, $direction) {
             if ('ASC' == $direction) {
                 return $a[$key] > $b[$key];
             } else {
                 return $a[$key] < $b[$key];
             }
         };
     };
     if (Arrays::is($fieldOrder) && !Arrays::is($orderDirection)) {
         $t = array();
         foreach ($fieldOrder as $tmpField) {
             array_push($t, $orderDirection);
         }
         $orderDirection = $t;
     }
     if (!Arrays::is($fieldOrder) && Arrays::is($orderDirection)) {
         $orderDirection = Arrays::first($orderDirection);
     }
     if (Arrays::is($fieldOrder) && Arrays::is($orderDirection)) {
         for ($i = 0; $i < count($fieldOrder); $i++) {
             usort($res, $sortFunc($fieldOrder[$i], $orderDirection[$i]));
         }
     } else {
         usort($res, $sortFunc($fieldOrder, $orderDirection));
     }
     $this->results = $res;
     return $this;
 }
Exemple #19
0
 public function order($fieldOrder = 'date_create', $orderDirection = 'ASC', $results = array())
 {
     $res = count($results) ? $results : $this->currrentRes();
     if (empty($res)) {
         return $this;
     }
     $data = $this->makeData($res);
     $fields = array_keys(Arrays::first($data)->assoc());
     $sort = array();
     foreach ($data as $objectCreated) {
         foreach ($fields as $key) {
             $value = isset($objectCreated->{$key}) ? $objectCreated->{$key} : null;
             $sort[$key][] = $value;
         }
     }
     $asort = array();
     foreach ($sort as $key => $rows) {
         for ($i = 0; $i < count($rows); $i++) {
             if (empty(${$key}) || is_string(${$key})) {
                 ${$key} = array();
             }
             $asort[$i][$key] = $rows[$i];
             array_push(${$key}, $rows[$i]);
         }
     }
     if (Arrays::is($fieldOrder) && !Arrays::is($orderDirection)) {
         $t = array();
         foreach ($fieldOrder as $tmpField) {
             array_push($t, $orderDirection);
         }
         $orderDirection = $t;
     }
     if (Arrays::is($fieldOrder) && Arrays::is($orderDirection)) {
         if (count($orderDirection) < count($fieldOrder)) {
             throw new Exception('You must provide the same arguments number of fields sorting and directions sorting.');
         }
         if (count($fieldOrder) == 1) {
             $fieldOrder = Arrays::first($fieldOrder);
             if ('ASC' == Inflector::upper(Arrays::first($orderDirection))) {
                 array_multisort(${$fieldOrder}, SORT_ASC, $asort);
             } else {
                 array_multisort(${$fieldOrder}, SORT_DESC, $asort);
             }
         } elseif (count($fieldOrder) > 1) {
             $params = array();
             foreach ($fieldOrder as $k => $tmpField) {
                 $tmpSort = isset($orderDirection[$k]) ? $orderDirection[$k] : 'ASC';
                 $params[] = ${$tmpField};
                 $params[] = 'ASC' == $tmpSort ? SORT_ASC : SORT_DESC;
             }
             $params[] = $asort;
             call_user_func_array('array_multisort', $params);
         }
     } else {
         if ('ASC' == Inflector::upper($orderDirection)) {
             array_multisort(${$fieldOrder}, SORT_ASC, $asort);
         } else {
             array_multisort(${$fieldOrder}, SORT_DESC, $asort);
         }
     }
     $collection = array();
     foreach ($asort as $key => $row) {
         $tmpId = $row['id'];
         array_push($collection, $tmpId);
     }
     $this->results = $collection;
     return $this;
 }
Exemple #20
0
 private function values($row)
 {
     if (is_object($row)) {
         if ($row instanceof Container) {
             $row = $this->toArray($row);
         }
     }
     if (Arrays::is($row)) {
         return array_values($row);
     }
     return array();
 }
Exemple #21
0
 /** Resolve a single dependency with an collections */
 private function _lookupRecursive($item)
 {
     if (Arrays::is($item)) {
         $collection = array();
         foreach ($item as $k => $v) {
             $collection[$k] = $this->_lookupRecursive($v);
         }
         return $collection;
     } else {
         return $this->lookup($item);
     }
 }
Exemple #22
0
 public static function lng($value, $lng = null)
 {
     if (null === $lng) {
         $lng = container()->getCmsLanguage();
         if (null === $lng) {
             $lng = static::getOption('default_language');
         }
     }
     if (Arrays::is($value)) {
         if (Arrays::exists($lng, $value)) {
             return $value[$lng];
         }
     }
     return '';
 }
Exemple #23
0
 /**
  * Fire an event and call the listeners.
  *
  * @param  string  $event
  * @param  mixed   $payload
  * @param  bool    $halt
  * @return array|null
  */
 public function fire($event, $payload = array(), $halt = false)
 {
     $responses = array();
     // If an array is not given to us as the payload, we will turn it into one so
     // we can easily use call_user_func_array on the listeners, passing in the
     // payload to each of them so that they receive each of these arguments.
     if (!Arrays::is($payload)) {
         $payload = array($payload);
     }
     $this->firing[] = $event;
     foreach ($this->getListeners($event) as $listener) {
         $response = call_user_func_array($listener, $payload);
         // If a response is returned from the listener and event halting is enabled
         // we will just return this response, and not call the rest of the event
         // listeners. Otherwise we will add the response on the response list.
         if (!is_null($response) && $halt) {
             array_pop($this->firing);
             return $response;
         }
         // If a boolean false is returned from a listener, we will stop propagating
         // the event to any further listeners down in the chain, else we keep on
         // looping through the listeners and firing every one in our sequence.
         if ($response === false) {
             break;
         }
         $responses[] = $response;
     }
     array_pop($this->firing);
     return $halt ? null : $responses;
 }
Exemple #24
0
 public static function substr($str, $start, $length = false, $encoding = 'utf-8')
 {
     if (Arrays::is($str)) {
         return false;
     }
     if (function_exists('mb_substr')) {
         return mb_substr($str, (int) $start, $length === false ? static::length($str) : (int) $length, $encoding);
     }
     return substr($str, $start, $length === false ? static::length($str) : (int) $length);
 }
Exemple #25
0
 public function backup()
 {
     $newline = NL;
     $tables = $this->_query('SHOW TABLES');
     if (Arrays::is($tables)) {
         $count = count($tables);
     } else {
         $count = $tables->rowCount();
     }
     if (false === $tables) {
         throw new Exception("This database {$this->_entity} contains no table.");
     }
     $output = '';
     foreach ($tables as $table) {
         $table = current($table);
         $queryTable = "SHOW CREATE TABLE `" . $this->_dbName . '`.`' . $table . '`';
         $res = $this->_query($queryTable);
         if (is_array($res)) {
             $count = count($res);
         } else {
             $count = $res->rowCount();
         }
         if (false === $res || 1 > $count) {
             continue;
         }
         $res = Arrays::first($res);
         $create = $res[1];
         $output .= '#' . $newline . '# TABLE STRUCTURE FOR: ' . $table . $newline . '#' . $newline . $newline;
         $output .= 'DROP TABLE IF EXISTS ' . $table . ';' . $newline . $newline;
         $output .= $create . ';' . $newline . $newline;
         $res = $this->_query("SELECT * FROM {$table}");
         if (Arrays::is($res)) {
             $count = count($res);
         } else {
             $count = $res->rowCount();
         }
         if (false === $res || 1 > $count) {
             continue;
         }
         foreach ($res as $row) {
             $fields = array();
             $values = array();
             foreach ($row as $key => $value) {
                 if (!is_numeric($key)) {
                     $fields[] = $key;
                     $values[] = "'" . addslashes($value) . "'";
                 }
             }
             $output .= 'INSERT INTO ' . $table . ' (' . implode(', ', $fields) . ') VALUES (' . implode(', ', $values) . ');' . $newline;
         }
         $output .= $newline;
     }
     return $output;
 }
Exemple #26
0
 /**
  * Make a string version of a value.
  *
  * @param mixed $value
  * @return string
  */
 private static function stringify($value)
 {
     if (is_bool($value)) {
         return $value ? '<TRUE>' : '<FALSE>';
     }
     if (is_scalar($value)) {
         $val = (string) $value;
         if (strlen($val) > 100) {
             $val = substr($val, 0, 97) . '...';
         }
         return $val;
     }
     if (Arrays::is($value)) {
         return '<ARRAY>';
     }
     if (is_object($value)) {
         return get_class($value);
     }
     if (is_resource($value)) {
         return '<RESOURCE>';
     }
     if ($value === null) {
         return '<NULL>';
     }
     return 'unknown';
 }
Exemple #27
0
 /**
  * Check the HTTP headers for signs of mobile.
  * This is the fastest mobile check possible; it's used
  * inside isMobile() method.
  *
  * @return bool
  */
 public function checkHttpHeadersForMobile()
 {
     foreach ($this->getMobileHeaders() as $mobileHeader => $matchType) {
         if (isset($this->httpHeaders[$mobileHeader])) {
             if (Arrays::is($matchType['matches'])) {
                 foreach ($matchType['matches'] as $_match) {
                     if (strpos($this->httpHeaders[$mobileHeader], $_match) !== false) {
                         return true;
                     }
                 }
                 return false;
             } else {
                 return true;
             }
         }
     }
     return false;
 }
Exemple #28
0
 private static function listing($type, $list, $attributes = array())
 {
     $html = '';
     if (count($list) == 0) {
         return $html;
     }
     foreach ($list as $key => $value) {
         // If the value is an array, we will recurse the function so that we can
         // produce a nested list within the list being built. Of course, nested
         // lists may exist within nested lists, etc.
         if (Arrays::is($value)) {
             if (is_int($key)) {
                 $html .= static::listing($type, $value);
             } else {
                 $html .= '<li>' . $key . static::listing($type, $value) . '</li>';
             }
         } else {
             $html .= '<li>' . static::entities($value) . '</li>';
         }
     }
     return '<' . $type . static::attributes($attributes) . '>' . $html . '</' . $type . '>';
 }
Exemple #29
0
 public function order($fieldOrder, $orderDirection = 'ASC', $results = array())
 {
     $res = count($results) ? $results : $this->results;
     if (empty($res)) {
         return $this;
     }
     $keyCache = sha1('RDB_order_' . serialize($fieldOrder) . serialize($orderDirection) . serialize($res) . $this->entity);
     $cached = $this->cached($keyCache);
     if (empty($cached)) {
         $settings = isAke(self::$configs, $this->entity);
         $_fields = isAke($settings, 'fields');
         $fields = empty($_fields) ? array_keys(Arrays::first($res)) : $_fields;
         $sort = array();
         foreach ($res as $i => $tab) {
             foreach ($fields as $k) {
                 $value = isAke($tab, $k, null);
                 $sort[$k][] = $value;
             }
         }
         $asort = array();
         foreach ($sort as $key => $rows) {
             for ($i = 0; $i < count($rows); $i++) {
                 if (empty(${$key}) || is_string(${$key})) {
                     ${$key} = array();
                 }
                 $asort[$i][$key] = $rows[$i];
                 array_push(${$key}, $rows[$i]);
             }
         }
         if (Arrays::is($fieldOrder) && !Arrays::is($orderDirection)) {
             $t = array();
             foreach ($fieldOrder as $tmpField) {
                 array_push($t, $orderDirection);
             }
             $orderDirection = $t;
         }
         if (Arrays::is($fieldOrder) && Arrays::is($orderDirection)) {
             if (count($orderDirection) < count($fieldOrder)) {
                 throw new Exception('You must provide the same arguments number of fields sorting and directions sorting.');
             }
             if (count($fieldOrder) == 1) {
                 $fieldOrder = Arrays::first($fieldOrder);
                 if ('ASC' == Inflector::upper(Arrays::first($orderDirection))) {
                     array_multisort(${$fieldOrder}, SORT_ASC, $asort);
                 } else {
                     array_multisort(${$fieldOrder}, SORT_DESC, $asort);
                 }
             } elseif (count($fieldOrder) > 1) {
                 $params = array();
                 foreach ($fieldOrder as $k => $tmpField) {
                     $tmpSort = isset($orderDirection[$k]) ? $orderDirection[$k] : 'ASC';
                     $params[] = ${$tmpField};
                     $params[] = 'ASC' == $tmpSort ? SORT_ASC : SORT_DESC;
                 }
                 $params[] = $asort;
                 call_user_func_array('array_multisort', $params);
             }
         } else {
             if ('ASC' == Inflector::upper($orderDirection)) {
                 array_multisort(${$fieldOrder}, SORT_ASC, $asort);
             } else {
                 array_multisort(${$fieldOrder}, SORT_DESC, $asort);
             }
         }
         $collection = array();
         foreach ($asort as $key => $row) {
             array_push($collection, $row);
         }
         $this->cached($keyCache, $collection);
     } else {
         $collection = $cached;
     }
     $this->results = $collection;
     return $this;
 }
Exemple #30
0
        static $i = array();
        $db = isAke($i, $entity, null);
        if (is_null($db)) {
            $i[$entity] = $db = new Nodedb($ns, $entity);
        }
        return $db;
    }
});
context('url')->to(function ($name, $args = array()) {
    $routes = container()->getRoutes();
    foreach ($routes as $route) {
        $nameRoute = $route->name;
        if (!is_null($nameRoute)) {
            if ($nameRoute == $name) {
                $path = $route->path;
                $args = $args instanceof Container ? $args->assoc() : !Arrays::is($args) ? array() : $args;
                if (count($args)) {
                    $max = count($args);
                    for ($i = 1; $i <= $max; $i++) {
                        $keyParam = "param{$i}";
                        $param = $route->{$keyParam};
                        $val = isAke($args, $param, 'undefined');
                        $path = strReplaceFirst('(.*)', $val, $path);
                    }
                }
                return trim(urldecode(URLSITE), '/') . $path;
            }
        }
    }
    return urldecode(URLSITE);
});