public function afterDispatch(Event $event, Request $request, Response $response) { if (Configure::read('debug') || !isset($request->params['cache']) || $request->params['cache'] !== true) { return; } unset($request->params['cache']); $cacheKey = $this->_getCacheKey($request); if ($cacheKey !== false) { $content = $response->body(); Cache::write($cacheKey, $content, 'wasabi/cms/pages'); } }
/** * Get all options * * @param bool $force Force * @return array|mixed */ public static function getAll($force = false) { if ($force === true || self::$_config['cache'] === false || self::$_config['cache'] === true && !Cache::read(self::$_config['cache_name'])) { $options = self::$_table->find('all'); $optionsArray = []; foreach ($options as $v) { $value = $v->{self::$_config['column_value']}; $setting = Settings::getSetting($v->{self::$_config['column_key']}); if (!is_null($setting)) { switch ($setting['type']) { case 'boolean': $value = boolval($value); break; case 'integer': $value = intval($value); break; case 'float': $value = floatval($value); break; } } $optionsArray[$v->{self::$_config['column_key']}] = $value; } if (self::$_config['cache'] === true) { Cache::write(self::$_config['cache_name'], $optionsArray, self::$_config['cache_config']); } return $optionsArray; } return Cache::read(self::$_config['cache_name']); }
/** * Prepares some variables used in "default.ctp" layout, such as skin color to use, * pending comments counter, etc. * * @return array Associative array */ function backendLayoutVars() { $layoutOptions = []; $skin = theme()->settings('skin'); $boxClass = 'success'; $pendingComments = Cache::read('pending_comments', 'pending_comments'); if ($pendingComments === false) { $pendingComments = TableRegistry::get('Comment.Comments')->find()->where(['Comments.status' => 'pending', 'Comments.table_alias' => 'contents'])->count(); Cache::write('pending_comments', $pendingComments, 'pending_comments'); } $pendingComments = !$pendingComments ? '' : $pendingComments; if (strpos($skin, 'blue') !== false || strpos($skin, 'black') !== false) { $boxClass = 'info'; } elseif (strpos($skin, 'green') !== false) { $boxClass = 'success'; } elseif (strpos($skin, 'red') !== false || strpos($skin, 'purple') !== false) { $boxClass = 'danger'; } elseif (strpos($skin, 'yellow') !== false) { $boxClass = 'warning'; } if (theme()->settings('fixed_layout')) { $layoutOptions[] = 'fixed'; } if (theme()->settings('boxed_layout')) { $layoutOptions[] = 'layout-boxed'; } if (theme()->settings('collapsed_sidebar')) { $layoutOptions[] = 'sidebar-collapse'; } return compact('skin', 'layoutOptions', 'boxClass', 'pendingComments'); }
/** * Establishes a connection to the salesforce server * * @param array $config configuration to be used for creating connection * @return bool true on success */ protected function _connect(array $config) { $this->config = $config; if (empty($this->config['my_wsdl'])) { throw new \ErrorException("A WSDL needs to be provided"); } else { $wsdl = CONFIG . DS . $this->config['my_wsdl']; } $mySforceConnection = new \SforceEnterpriseClient(); $mySoapClient = $mySforceConnection->createConnection($wsdl); $sflogin = (array) Cache::read('salesforce_login', 'salesforce'); if (!empty($sflogin['sessionId'])) { $mySforceConnection->setSessionHeader($sflogin['sessionId']); $mySforceConnection->setEndPoint($sflogin['serverUrl']); } else { try { $mylogin = $mySforceConnection->login($this->config['username'], $this->config['password']); $sflogin = array('sessionId' => $mylogin->sessionId, 'serverUrl' => $mylogin->serverUrl); Cache::write('salesforce_login', $sflogin, 'salesforce'); } catch (Exception $e) { $this->log("Error logging into salesforce - Salesforce down?"); $this->log("Username: "******"Password: " . $this->config['password']); } } $this->client = $mySforceConnection; $this->connected = true; return $this->connected; }
public function index() { if (($books = Cache::read('exlibrisBooksIndex')) === false) { $books = $this->Books->find('all')->contain('Publishers')->all(); Cache::write('exlibrisBooksIndex', $books); } $this->set('books', $books); $this->set('_serialize', ['books']); }
/** * Write the data into the Cache with the passed key. * * @param int|object|string $data The data to save in the Cache. * @param string $key The key to save the data. * * @return bool */ protected function _writeCache($data, $key) { if (empty($data) || empty($key)) { return true; } $result = Cache::write($key, $data, 'statistics'); if ($result) { return true; } return false; }
/** * Internal method to get the latest photos * @param int $limit Limit * @return array * @uses MeInstagram\Utility\Instagram::recent() */ protected function _latest($limit = 15) { //Tries to get data from the cache $photos = Cache::read($cache = sprintf('latest_%s', $limit), 'instagram'); //If the data are not available from the cache if (empty($photos)) { list($photos) = Instagram::recent(null, $limit); Cache::write($cache, $photos, 'instagram'); } return $photos; }
public function view($slug) { $pagina = Cache::read('pagina_view_' . $slug); if ($pagina === false) { $pagina = $this->Paginas->getPaginaBySlug($slug); Cache::write('pagina_view_' . $slug, $pagina); } if (!$pagina) { throw new NotFoundException(); } $this->set(compact('pagina')); }
/** * Write user failed login. * * @param Controller $controller * @return void */ protected function _writeFailedLogin(Controller $controller) { $cacheConfig = 'auth'; if ($controller->request->param('prefix') == 'admin') { $cacheConfig .= '_admin'; } $cacheName = 'failed_' . $controller->request->data('username'); $cacheValue = (int) Cache::read($cacheName, $cacheConfig); $cookieVal = $controller->Cookie->read('fail.auth'); $controller->Cookie->config(['expires' => '+300 seconds']); $controller->Cookie->write('fail.auth', (int) $cookieVal + 1); Cache::write($cacheName, (int) $cacheValue + 1, $cacheConfig); }
/** * Renders the login form. * * @return \Cake\Network\Response|null */ public function login() { $this->loadModel('User.Users'); $this->viewBuilder()->layout('login'); if ($this->request->is('post')) { $loginBlocking = plugin('User')->settings('failed_login_attempts') && plugin('User')->settings('failed_login_attempts_block_seconds'); $continue = true; if ($loginBlocking) { Cache::config('users_login', ['duration' => '+' . plugin('User')->settings('failed_login_attempts_block_seconds') . ' seconds', 'path' => CACHE, 'engine' => 'File', 'prefix' => 'qa_', 'groups' => ['acl']]); $cacheName = 'login_failed_' . env('REMOTE_ADDR'); $cache = Cache::read($cacheName, 'users_login'); if ($cache && $cache['attempts'] >= plugin('User')->settings('failed_login_attempts')) { $blockTime = (int) plugin('User')->settings('failed_login_attempts_block_seconds'); $this->Flash->warning(__d('user', 'You have reached the maximum number of login attempts. Try again in {0} minutes.', $blockTime / 60)); $continue = false; } } if ($continue) { $user = $this->Auth->identify(); if ($user) { $this->Auth->setUser($user); if (!empty($user['id'])) { try { $user = $this->Users->get($user['id']); if ($user) { $this->Users->touch($user, 'Users.login'); $this->Users->save($user); } } catch (\Exception $e) { // invalid user } } return $this->redirect($this->Auth->redirectUrl()); } else { if ($loginBlocking && isset($cache) && isset($cacheName)) { $cacheStruct = ['attempts' => 0, 'last_attempt' => 0, 'ip' => '', 'request_log' => []]; $cache = array_merge($cacheStruct, $cache); $cache['attempts'] += 1; $cache['last_attempt'] = time(); $cache['ip'] = env('REMOTE_ADDR'); $cache['request_log'][] = ['data' => $this->request->data, 'time' => time()]; Cache::write($cacheName, $cache, 'users_login'); } $this->Flash->danger(__d('user', 'Username or password is incorrect.')); } } } $user = $this->Users->newEntity(); $this->title(__d('user', 'Login')); $this->set(compact('user')); }
/** * {@inheritDoc} * */ public function describe($name, array $options = []) { $options += ['forceRefresh' => false]; $cacheConfig = $this->cacheMetadata(); $cacheKey = $this->cacheKey($name); if (!empty($cacheConfig) && !$options['forceRefresh']) { $cached = Cache::read($cacheKey, $cacheConfig); if ($cached !== false) { return $cached; } } $table = parent::describe($name, $options); if (!empty($cacheConfig)) { Cache::write($cacheKey, $table, $cacheConfig); } return $table; }
/** * Returns a application access token. * * @return string|bool The access token or false in case of a failure */ public function accessToken() { $cacheKey = 'twitter-' . $this->config('name') . '-token'; if (Cache::read($cacheKey) !== false) { return Cache::read($cacheKey); } $bearerToken = $this->bearerToken(); if (!$bearerToken) { return false; } $client = new Client(['headers' => ['Authorization' => 'Basic ' . $bearerToken], 'host' => 'api.twitter.com', 'scheme' => 'https']); $response = $client->post('/oauth2/token', ['grant_type' => 'client_credentials']); if (!$response->isOk() || !$response->json['token_type']) { return false; } Cache::write($cacheKey, $response->json['access_token']); return $response->json['access_token']; }
/** * Returns a list of Controller names found in /src/Controller/Api. * * @return array List holding sorted Controller names */ public static function getApiControllers() { $cached = Cache::read('api_controllers'); if ($cached) { return $cached; } $dir = new Folder(APP . 'Controller' . DS . Inflector::camelize(Configure::read('App++.Api.prefix'))); $controllerFiles = $dir->find('.*Controller\\.php'); if (!$controllerFiles) { return false; } $result = []; foreach ($controllerFiles as $controllerFile) { $result[] = substr($controllerFile, 0, strlen($controllerFile) - 14); } sort($result); Cache::write('api_controllers', $result); return $result; }
public function main() { //Cache::clear(false); foreach ($this->Incidents->filterTimes as $filter_string => $filter) { foreach ($this->Incidents->summarizableFields as $field) { $this->out("processing " . $filter_string . ":" . $field); $entriesWithCount = $this->Reports->getRelatedByField($field, 25, false, false, $filter["limit"]); $entriesWithCount = json_encode($entriesWithCount); Cache::write($field . '_' . $filter_string, $entriesWithCount); } $query = array('group' => 'grouped_by', 'order' => 'Incidents.created'); if (isset($filter["limit"])) { $query["conditions"] = array('Incidents.created >=' => $filter["limit"]); } $downloadStats = $this->Incidents->find('all', $query); $downloadStats->select(['grouped_by' => $filter["group"], 'date' => "DATE_FORMAT(Incidents.created, '%a %b %d %Y %T')", 'count' => $downloadStats->func()->count('*')]); $downloadStats = json_encode($downloadStats->toArray()); Cache::write('downloadStats_' . $filter_string, $downloadStats); } }
protected function _icons() { $useCache = true; if (!empty($this->request->params['named']['reset'])) { $useCache = false; } if ($useCache && ($iconNames = Cache::read('country_icon_names')) !== false) { $this->Flash->info('Cache Used'); return $iconNames; } $handle = new Folder($this->imageFolder); $icons = $handle->read(true, true); $iconNames = []; foreach ($icons[1] as $icon) { # only use files (not folders) $iconNames[] = strtoupper(extractPathInfo('filename', $icon)); } Cache::write('country_icon_names', $iconNames); return $iconNames; }
public static function loadListeners() { $eventManager = EventManager::instance(); $cached = Cache::read('EventHandlers', 'default'); if ($cached === false) { $eventHandlers = Configure::read('EventHandlers'); $validKeys = array('eventKey' => null, 'options' => array()); $cached = array(); if (!empty($eventHandlers) && is_array($eventHandlers)) { foreach ($eventHandlers as $eventHandler => $eventOptions) { $eventKey = null; if (is_numeric($eventHandler)) { $eventHandler = $eventOptions; $eventOptions = array(); } list($plugin, $class) = pluginSplit($eventHandler); if (!empty($eventOptions)) { extract(array_intersect_key($eventOptions, $validKeys)); } if (isset($eventOptions['options']['className'])) { list($plugin, $class) = pluginSplit($eventOptions['options']['className']); } if (class_exists('\\' . $plugin . '\\Event\\' . $class)) { $cached[] = compact('plugin', 'class', 'eventKey', 'eventOptions'); } else { Log::error(__d('croogo', 'EventHandler %s not found in plugin %s', $class, $plugin)); } } Cache::write('EventHandlers', $cached, 'default'); } } foreach ($cached as $cache) { extract($cache); if (Plugin::loaded($plugin)) { $settings = isset($eventOptions['options']) ? $eventOptions['options'] : array(); $namespace = '\\' . $plugin . '\\Event\\' . $class; $listener = new $namespace($settings); $eventManager->on($listener, $eventKey, $eventOptions); } } }
protected function initData() { $menus = \Cake\Cache\Cache::read('admin_menus'); if ($menus === false) { $Menu = \Cake\ORM\TableRegistry::get('cwp_menu'); $menus = $Menu->find()->hydrate(false)->where('status = 1')->orderDesc('rank')->toArray(); $menus = \Admin\Utils\Util::getMenu($menus); \Cake\Cache\Cache::write('admin_menus', $menus); } $this->_menus = $menus; $controller = strtolower($this->request->param('controller')); $action = strtolower($this->request->param('action')); $url = '/admin/' . $controller . '/' . $action; $this->_url = $url; $active = null; foreach ($menus as $value) { if (isset($value['child'])) { foreach ($value['child'] as $sub_menu) { if ($sub_menu['node'] == $url) { $this->_pageTitle = $sub_menu['name']; $this->_breadFirst = ['name' => $value['name'], 'node' => $value['node']]; $this->_breadSecond = ['name' => $sub_menu['name'], 'node' => $sub_menu['node']]; break; } if (isset($sub_menu['child'])) { foreach ($sub_menu['child'] as $v) { if ($v['node'] == $url) { $active = $sub_menu['node']; $this->_active = $active; $this->_pageTitle = $v['name']; $this->_breadFirst = ['name' => $value['name'], 'node' => $value['node']]; $this->_breadSecond = ['name' => $sub_menu['name'], 'node' => $sub_menu['node']]; } } } } } } }
/** * Authorizes current logged in user, if user belongs to the "administrator" * he/she is automatically authorized. * * @param array $user Active user data * @param \Cake\Network\Request $request Request instance * @return bool True if user is can access this request */ public function authorize($user, Request $request) { if ($request->is('userAdmin')) { return true; } $user = user(); $path = $this->requestPath($request); $cacheKey = 'permissions_' . intval($user->id); $permissions = Cache::read($cacheKey, 'permissions'); if ($permissions === false) { $permissions = []; Cache::write($cacheKey, [], 'permissions'); } if (!isset($permissions[$path])) { $allowed = $user->isAllowed($path); $permissions[$path] = $allowed; Cache::write($cacheKey, $permissions, 'permissions'); } else { $allowed = $permissions[$path]; } return $allowed; }
public function stats() { $filter = $this->_getTimeFilter(); $relatedEntries = array(); $filter_string = $this->request->query('filter'); if (!$filter_string) { $filter_string = "all_time"; } $entriesWithCount = array(); //Cache::clear(false); foreach (TableRegistry::get('Incidents')->summarizableFields as $field) { if (($entriesWithCount = Cache::read($field . '_' . $filter_string)) === false) { $entriesWithCount = TableRegistry::get('Reports')->getRelatedByField($field, 25, false, false, $filter["limit"]); $entriesWithCount = json_encode($entriesWithCount); Cache::write($field . '_' . $filter_string, $entriesWithCount); } $relatedEntries[$field] = json_decode($entriesWithCount, TRUE); } $this->set("related_entries", $relatedEntries); $this->set('columns', TableRegistry::get('Incidents')->summarizableFields); $this->set('filter_times', TableRegistry::get('Incidents')->filterTimes); $this->set('selected_filter', $this->request->query('filter')); $query = array('group' => 'grouped_by', 'order' => 'Incidents.created'); if (isset($filter["limit"])) { $query["conditions"] = array('Incidents.created >=' => $filter["limit"]); } TableRegistry::get('Incidents')->recursive = -1; $downloadStats = array(); if (($downloadStats = Cache::read('downloadStats_' . $filter_string)) === false) { $downloadStats = TableRegistry::get('Incidents')->find('all', $query); $downloadStats->select(['grouped_by' => $filter["group"], 'date' => "DATE_FORMAT(Incidents.created, '%a %b %d %Y %T')", 'count' => $downloadStats->func()->count('*')]); $downloadStats = json_encode($downloadStats->toArray()); Cache::write('downloadStats_' . $filter_string, $downloadStats); } $this->set('download_stats', json_decode($downloadStats, TRUE)); }
/** * @param ComponentRegistry $registry The controller for this request. * @param array $config An array of config. This class does not use any config. */ public function __construct(ComponentRegistry $registry, array $config = []) { parent::__construct($registry, $config); if (!file_exists(CONFIG . $this->config('hierarchyFile'))) { throw new Exception(sprintf("Provided hierarchy config file %s doesn't exist.", $this->config('hierarchyFile'))); } if (!file_exists(CONFIG . $this->config('aclFile'))) { throw new Exception(sprintf("Provided ACL config file %s doesn't exist.", $this->config('aclFile'))); } // caching $hierarchyModified = filemtime(CONFIG . $this->config('hierarchyFile')); $aclModified = filemtime(CONFIG . $this->config('aclFile')); $lastModified = $hierarchyModified > $aclModified ? $hierarchyModified : $aclModified; if (Cache::read('hierarchy_auth_build_time') < $lastModified) { $this->_hierarchy = $this->_getHierarchy(); $this->_acl = $this->_getAcl(); Cache::write('hierarchy_auth_cache', ['acl' => $this->_acl, 'hierarchy' => $this->_hierarchy]); Cache::write('hierarchy_auth_build_time', time()); } else { $cache = Cache::read('hierarchy_auth_cache'); $this->_hierarchy = $cache['hierarchy']; $this->_acl = $cache['acl']; } }
/** * Test clearing a cache group * * @return void */ public function testGroupClear() { Cache::config('memcached_groups', ['engine' => 'Memcached', 'duration' => 3600, 'groups' => ['group_a', 'group_b']]); $this->assertTrue(Cache::write('test_groups', 'value', 'memcached_groups')); $this->assertTrue(Cache::clearGroup('group_a', 'memcached_groups')); $this->assertFalse(Cache::read('test_groups', 'memcached_groups')); $this->assertTrue(Cache::write('test_groups', 'value2', 'memcached_groups')); $this->assertTrue(Cache::clearGroup('group_b', 'memcached_groups')); $this->assertFalse(Cache::read('test_groups', 'memcached_groups')); }
/** * Sets to cache the timestamp of the next record to be published. * This value can be used to check if the cache is valid * @return void * @uses $cache */ public function setNextToBePublished() { $next = $this->find()->select('created')->where([sprintf('%s.active', $this->alias()) => true, sprintf('%s.created >', $this->alias()) => new Time()])->order([sprintf('%s.created', $this->alias()) => 'ASC'])->first(); $next = empty($next->created) ? false : $next->created->toUnixString(); Cache::write('next_to_be_published', $next, $this->cache); }
/** * Helper function called on write for cache sessions. * * @param int $id ID that uniquely identifies session in database * @param mixed $data The value of the data to be saved. * @return bool True for successful write, false otherwise. */ public function write($id, $data) { return Cache::write($id, $data, $this->_options['config']); }
/** * Prepares the given threaded list of terms. * * @param array $terms Threaded list of terms * @param \Cake\Datasource\EntityInterface $block The block */ public static function termsForBlock($terms, $block) { foreach ($terms as $term) { $title = $term->name; if (!empty($block->settings['show_counters'])) { $countCacheKey = "t{$term->id}"; $count = (string) Cache::read($countCacheKey, 'terms_count'); if ($count == '') { $count = (int) TableRegistry::get('Taxonomy.EntitiesTerms')->find()->where(['EntitiesTerms.term_id' => $term->id])->count(); Cache::write($countCacheKey, $count, 'terms_count'); } $title .= " ({$count})"; } $term->set('title', $title); $term->set('url', "/find/term:{$term->slug}"); if (!empty($term->children)) { $term->set('expanded', true); static::termsForBlock($term->children, $block); } } }
/** * Used to write runtime configuration into Cache. Stored runtime configuration can be * restored using `Configure::restore()`. These methods can be used to enable configuration managers * frontends, or other GUI type interfaces for configuration. * * @param string $name The storage name for the saved configuration. * @param string $cacheConfig The cache configuration to save into. Defaults to 'default' * @param array $data Either an array of data to store, or leave empty to store all values. * @return bool Success */ public static function store($name, $cacheConfig = 'default', $data = null) { if ($data === null) { $data = static::$_values; } return Cache::write($name, $data, $cacheConfig); }
/** * Returns the targeted field names for all configured formatter, live and * normal caching. * * If a formatter cannot be found, it will silently be removed from the list. * * @return array */ protected function formatters() { if ($this->loaded === false) { $useCache = $this->useCache(); $cacheKey = $this->cacheKey(); $cache = true === $useCache ? Cache::read($cacheKey) : false; if (false === $cache) { $cache = []; foreach ((array) $this->config('formatters') as $callback => $conditions) { $tokens = preg_split('/::/', $callback); if (method_exists($tokens[0], $tokens[1])) { $cache[$callback] = $this->fieldsByConditions($conditions); } } if (true === $useCache) { Cache::write($cacheKey, $cache); } } $this->cache = $cache; $this->loaded = true; } return $this->cache; }
/** * Create a cached block of view logic. * * This allows you to cache a block of view output into the cache * defined in `elementCache`. * * This method will attempt to read the cache first. If the cache * is empty, the $block will be run and the output stored. * * @param callable $block The block of code that you want to cache the output of. * @param array $options The options defining the cache key etc. * @return string The rendered content. * @throws \RuntimeException When $options is lacking a 'key' option. */ public function cache(callable $block, array $options = []) { $options += ['key' => '', 'config' => $this->elementCache]; if (empty($options['key'])) { throw new RuntimeException('Cannot cache content with an empty key'); } $result = Cache::read($options['key'], $options['config']); if ($result) { return $result; } ob_start(); $block(); $result = ob_get_clean(); Cache::write($options['key'], $result, $options['config']); return $result; }
/** * Method that returns posts tags urls * @return array * @uses MeCms\Utility\SitemapBuilder::parse() */ public static function postsTags() { $table = TableRegistry::get('MeCms.Tags'); $url = Cache::read('sitemap', $table->cache); if ($url) { return $url; } $tags = $table->find('all')->select(['tag', 'modified'])->order(['tag' => 'ASC'])->where(['post_count >' => 0]); if ($tags->isEmpty()) { return []; } $latest = $table->find()->select(['modified'])->order(['modified' => 'DESC'])->firstOrFail(); //Adds the tags index $url[] = self::parse(['_name' => 'postsTags'], ['lastmod' => $latest->modified]); //Adds all tags $url = am($url, array_map(function ($tag) { return self::parse(['_name' => 'postsTag', $tag->slug], ['lastmod' => $tag->modified]); }, $tags->toArray())); Cache::write('sitemap', $url, $table->cache); return $url; }
/** * Test clearing a cache group * * @return void */ public function testGroupClear() { Cache::config('apc_groups', array('engine' => 'Apc', 'duration' => 0, 'groups' => array('group_a', 'group_b'), 'prefix' => 'test_')); $this->assertTrue(Cache::write('test_groups', 'value', 'apc_groups')); $this->assertTrue(Cache::clearGroup('group_a', 'apc_groups')); $this->assertFalse(Cache::read('test_groups', 'apc_groups')); $this->assertTrue(Cache::write('test_groups', 'value2', 'apc_groups')); $this->assertTrue(Cache::clearGroup('group_b', 'apc_groups')); $this->assertFalse(Cache::read('test_groups', 'apc_groups')); }
/** * @return Array 2d heading and values */ public function getOfficialIsoList() { $this->HtmlDom = new HtmlDom(); if (!($res = Cache::read('lov_gov_iso_list'))) { $res = file_get_contents('http://www.loc.gov/standards/iso639-2/php/code_list.php'); $res = $this->HtmlDom->domFromString($res); Cache::write('lov_gov_iso_list', $res); } foreach ($res->find('table') as $element) { $languageArray = $element->plaintext; $languageArray = explode(TB . TB, $languageArray); array_shift($languageArray); $max = count($languageArray); $languageArray[$max - 1] = array_shift(explode(' ', $languageArray[$max - 1])); foreach ($languageArray as $key => $val) { $languageArray[$key] = trim(str_replace(["<", ">", '&', ''', '"', ' '], ["<", ">", '&', '\'', '"', ' '], $val)); } $languages = []; for ($i = 0; $i < $max; $i = $i + 4) { $iso3 = $languageArray[$i]; if (isset($languages[$iso3])) { continue; } $iso2 = $languageArray[$i + 1]; if (strpos($iso3, '(') !== false) { $iso3array = explode(NL, $iso3); foreach ($iso3array as $key => $val) { if (strpos($val, '(T)') === false) { continue; } $iso3 = trim(array_shift(explode('(', $val))); } } $languages[$iso3] = ['iso3' => $iso3, 'iso2' => $iso2, 'ori_name' => $languageArray[$i + 2]]; } $heading = ['ISO 639-2 Code (alpha3)', 'ISO 639-1 Code (alpha2)', 'English name of Language']; break; } return ['heading' => $heading, 'values' => $languages]; }