PHP IOHelper::getFolderName方法代码示例

 /**
  * @param $view
  * @param $data
  *
  * @return mixed
  */
 protected function render($view, $data)
 {
     if (!craft()->isConsole() && !craft()->request->isResourceRequest() && !craft()->request->isAjaxRequest() && craft()->config->get('devMode') && in_array(HeaderHelper::getMimeType(), array('text/html', 'application/xhtml+xml'))) {
         if (($userAgent = craft()->request->getUserAgent()) !== null && preg_match('/msie [5-9]/i', $userAgent)) {
             echo '<script type="text/javascript">';
             echo IOHelper::getFileContents(IOHelper::getFolderName(__FILE__) . '/../vendors/console-normalizer/normalizeconsole.min.js');
             echo "</script>\n";
         } else {
             $viewFile = craft()->path->getCpTemplatesPath() . 'logging/' . $view . '-firebug.php';
             include craft()->findLocalizedFile($viewFile, 'en');
         }
     }
 }

 /**
  * @param string|null $path
  * @param bool        $fetch
  *
  * @return array
  */
 public static function getAlerts($path = null, $fetch = false)
 {
     $alerts = array();
     $user = craft()->userSession->getUser();
     if (!$user) {
         return $alerts;
     }
     if (craft()->updates->isUpdateInfoCached() || $fetch) {
         // Fetch the updates regardless of whether we're on the Updates page or not, because the other alerts are
         // relying on cached Elliott info
         $updateModel = craft()->updates->getUpdates();
         // Get the license key status
         $licenseKeyStatus = craft()->et->getLicenseKeyStatus();
         // Invalid license?
         if ($licenseKeyStatus == LicenseKeyStatus::Invalid) {
             $alerts[] = Craft::t('Your license key is invalid.');
         } else {
             if (craft()->hasWrongEdition()) {
                 $alerts[] = Craft::t('You’re running Craft {edition} with a Craft {licensedEdition} license.', array('edition' => craft()->getEditionName(), 'licensedEdition' => craft()->getLicensedEditionName())) . ' <a class="go edition-resolution">' . Craft::t('Resolve') . '</a>';
             }
         }
         if ($path != 'updates' && $user->can('performUpdates')) {
             if (!empty($updateModel->app->releases)) {
                 if (craft()->updates->criticalCraftUpdateAvailable($updateModel->app->releases)) {
                     $alerts[] = Craft::t('There’s a critical Craft update available.') . ' <a class="go nowrap" href="' . UrlHelper::getUrl('updates') . '">' . Craft::t('Go to Updates') . '</a>';
                 }
             }
         }
         // Domain mismatch?
         if ($licenseKeyStatus == LicenseKeyStatus::Mismatched) {
             $licensedDomain = craft()->et->getLicensedDomain();
             $licenseKeyPath = craft()->path->getLicenseKeyPath();
             $licenseKeyFile = IOHelper::getFolderName($licenseKeyPath, false) . '/' . IOHelper::getFileName($licenseKeyPath);
             $message = Craft::t('The license located at {file} belongs to {domain}.', array('file' => $licenseKeyFile, 'domain' => '<a href="http://' . $licensedDomain . '" target="_blank">' . $licensedDomain . '</a>'));
             // Can they actually do something about it?
             if ($user->admin) {
                 $action = '<a class="go domain-mismatch">' . Craft::t('Transfer it to this domain') . '</a>';
             } else {
                 $action = Craft::t('Please notify one of your site’s admins.');
             }
             $alerts[] = $message . ' ' . $action;
         }
     }
     $allPluginAlerts = craft()->plugins->call('getCpAlerts', array($path, $fetch), true);
     foreach ($allPluginAlerts as $pluginAlerts) {
         $alerts = array_merge($alerts, $pluginAlerts);
     }
     return $alerts;
 }

 /**
  * Returns the revisioning manifest model.
  *
  * @return RevManifestModel|null
  */
 public function getManifest()
 {
     $status = craft()->config->get('revManifest');
     if (!$this->_manifest && $status !== false) {
         $manifestPath = craft()->config->get('revManifestPath');
         if (!$manifestPath) {
             $manifestPath = craft()->config->get('revManifestPath', 'revmanifest');
         }
         if (!file_exists($manifestPath)) {
             Craft::log(Craft::t('(Rev Manifest) The manifest file “{file}” doesn\'t exists.', array('file' => $manifestPath)), LogLevel::Error);
             return null;
         }
         $manifest = json_decode(file_get_contents($manifestPath), true);
         if (!$manifest) {
             Craft::log(Craft::t('(Rev Manifest) There was a problem reading the manifest file “{file}”.', array('file' => $manifestPath)), LogLevel::Error);
             return null;
         }
         $this->_manifest = new RevManifestModel();
         $this->_manifest->manifest = $manifest;
         $this->_manifest->manifestFolder = IOHelper::getFolderName($manifestPath);
     }
     return $this->_manifest;
 }

 /**
  * @param string|null $path
  * @param bool        $fetch
  *
  * @return array
  */
 public static function getAlerts($path = null, $fetch = false)
 {
     $alerts = array();
     $user = craft()->userSession->getUser();
     if (!$user) {
         return $alerts;
     }
     if (craft()->updates->isUpdateInfoCached() || $fetch) {
         // Fetch the updates regardless of whether we're on the Updates page or not, because the other alerts are
         // relying on cached Elliott info
         $updateModel = craft()->updates->getUpdates();
         if ($path != 'updates' && $user->can('performUpdates')) {
             if (!empty($updateModel->app->releases)) {
                 if (craft()->updates->criticalCraftUpdateAvailable($updateModel->app->releases)) {
                     $alerts[] = Craft::t('There’s a critical Craft update available.') . ' <a class="go nowrap" href="' . UrlHelper::getUrl('updates') . '">' . Craft::t('Go to Updates') . '</a>';
                 }
             }
         }
         // Domain mismatch?
         $licenseKeyStatus = craft()->et->getLicenseKeyStatus();
         if ($licenseKeyStatus == LicenseKeyStatus::MismatchedDomain) {
             $licensedDomain = craft()->et->getLicensedDomain();
             $licenseKeyPath = craft()->path->getLicenseKeyPath();
             $licenseKeyFile = IOHelper::getFolderName($licenseKeyPath, false) . '/' . IOHelper::getFileName($licenseKeyPath);
             $message = Craft::t('The license located at {file} belongs to {domain}.', array('file' => $licenseKeyFile, 'domain' => '<a href="http://' . $licensedDomain . '" target="_blank">' . $licensedDomain . '</a>'));
             // Can they actually do something about it?
             if ($user->admin) {
                 $action = '<a class="domain-mismatch">' . Craft::t('Transfer it to this domain?') . '</a>';
             } else {
                 $action = Craft::t('Please notify one of your site’s admins.');
             }
             $alerts[] = $message . ' ' . $action;
         }
     }
     return $alerts;
 }

 /**
  * Returns all the plugins.
  *
  * @param bool $enabledOnly Whether to only return plugins that are installed and enabled. Defaults to `true`.
  *
  * @return BasePlugin[] The plugins.
  */
 public function getPlugins($enabledOnly = true)
 {
     if ($enabledOnly) {
         return $this->_enabledPlugins;
     } else {
         if (!isset($this->_allPlugins)) {
             $this->_allPlugins = array();
             // Find all of the plugins in the plugins folder
             $pluginsPath = craft()->path->getPluginsPath();
             $pluginFolderContents = IOHelper::getFolderContents($pluginsPath, false);
             if ($pluginFolderContents) {
                 foreach ($pluginFolderContents as $pluginFolderContent) {
                     // Make sure it's actually a folder.
                     if (IOHelper::folderExists($pluginFolderContent)) {
                         $pluginFolderContent = IOHelper::normalizePathSeparators($pluginFolderContent);
                         $pluginFolderName = mb_strtolower(IOHelper::getFolderName($pluginFolderContent, false));
                         $pluginFilePath = IOHelper::getFolderContents($pluginFolderContent, false, ".*Plugin\\.php");
                         if (is_array($pluginFilePath) && count($pluginFilePath) > 0) {
                             $pluginFileName = IOHelper::getFileName($pluginFilePath[0], false);
                             // Chop off the "Plugin" suffix
                             $handle = mb_substr($pluginFileName, 0, mb_strlen($pluginFileName) - 6);
                             $lcHandle = mb_strtolower($handle);
                             // Validate that the lowercase plugin class handle is the same as the folder name
                             // and that we haven't already loaded a plugin with the same handle but different casing
                             if ($lcHandle === $pluginFolderName && !isset($this->_allPlugins[$lcHandle])) {
                                 $plugin = $this->getPlugin($handle, false);
                                 if ($plugin) {
                                     $this->_allPlugins[$lcHandle] = $plugin;
                                     $names[] = $plugin->getName();
                                 }
                             }
                         }
                     }
                 }
                 if (!empty($names)) {
                     // Sort plugins by name
                     array_multisort($names, $this->_allPlugins);
                 }
             }
         }
         return $this->_allPlugins;
     }
 }

 /**
  * Checks to see if the files that we are about to update are writable by Craft.
  *
  * @param string $unzipFolder
  * @param string $handle
  *
  * @return bool
  */
 private function _validateManifestPathsWritable($unzipFolder, $handle)
 {
     $manifestData = UpdateHelper::getManifestData($unzipFolder, $handle);
     $writableErrors = array();
     foreach ($manifestData as $row) {
         if (UpdateHelper::isManifestVersionInfoLine($row)) {
             continue;
         }
         $rowData = explode(';', $row);
         $filePath = IOHelper::normalizePathSeparators(($handle == 'craft' ? craft()->path->getAppPath() : craft()->path->getPluginsPath() . $handle . '/') . $rowData[0]);
         if (UpdateHelper::isManifestLineAFolder($filePath)) {
             $filePath = UpdateHelper::cleanManifestFolderLine($filePath);
         }
         // Check to see if the file/folder we need to update is writable.
         if (IOHelper::fileExists($filePath) || IOHelper::folderExists($filePath)) {
             if (!IOHelper::isWritable($filePath)) {
                 $writableErrors[] = $filePath;
             }
         } else {
             if (($folderPath = IOHelper::folderExists(IOHelper::getFolderName($filePath))) == true) {
                 if (!IOHelper::isWritable($folderPath)) {
                     $writableErrors[] = $filePath;
                 }
             }
         }
     }
     return $writableErrors;
 }

 /**
  * @param $match
  *
  * @return string
  */
 private function _normalizeCssUrl($match)
 {
     // Ignore root-relative, absolute, and data: URLs
     if (preg_match('/^(\\/|https?:\\/\\/|data:)/', $match[3])) {
         return $match[0];
     }
     // Clean up any relative folders at the beginning of the CSS URL
     $requestFolder = IOHelper::getFolderName(craft()->request->getPath());
     $requestFolderParts = array_filter(explode('/', $requestFolder));
     $cssUrlParts = array_filter(explode('/', $match[3]));
     while (isset($cssUrlParts[0]) && $cssUrlParts[0] == '..' && $requestFolderParts) {
         array_pop($requestFolderParts);
         array_shift($cssUrlParts);
     }
     $pathParts = array_merge($requestFolderParts, $cssUrlParts);
     $path = implode('/', $pathParts);
     $url = UrlHelper::getUrl($path);
     // Is this going to be a resource URL?
     $rootResourceUrl = UrlHelper::getUrl(craft()->config->getResourceTrigger()) . '/';
     $rootResourceUrlLength = strlen($rootResourceUrl);
     if (strncmp($rootResourceUrl, $url, $rootResourceUrlLength) === 0) {
         // Isolate the relative resource path
         $resourcePath = substr($url, $rootResourceUrlLength);
         // Give UrlHelper a chance to add the timestamp
         $url = UrlHelper::getResourceUrl($resourcePath);
     }
     // Return the normalized CSS URL declaration
     return $match[1] . $url . $match[4];
 }

 /**
  * @param $srcZip
  * @param $destFolder
  * @return bool
  */
 public function unzip($srcZip, $destFolder)
 {
     $zip = new \PclZip($srcZip);
     $tempDestFolders = null;
     // check to see if it's a valid archive.
     if (($zipFiles = $zip->extract(PCLZIP_OPT_EXTRACT_AS_STRING)) == false) {
         Craft::log('Tried to unzip ' . $srcZip . ', but PclZip thinks it is not a valid zip archive.', LogLevel::Error);
         return false;
     }
     if (count($zipFiles) == 0) {
         Craft::log($srcZip . ' appears to be an empty zip archive.', LogLevel::Error);
         return false;
     }
     // find out which directories we need to create in the destination.
     foreach ($zipFiles as $zipFile) {
         if (substr($zipFile['filename'], 0, 9) === '__MACOSX/') {
             continue;
         }
         $folderName = IOHelper::getFolderName($zipFile['filename']);
         if ($folderName == './') {
             $tempDestFolders[] = $destFolder . '/';
         } else {
             $tempDestFolders[] = $destFolder . '/' . rtrim(IOHelper::getFolderName($zipFile['filename']), '/');
         }
     }
     $tempDestFolders = array_unique($tempDestFolders);
     $finalDestFolders = array();
     foreach ($tempDestFolders as $tempDestFolder) {
         // Skip over the working directory
         if (rtrim($destFolder, '/') == rtrim($tempDestFolder, '/')) {
             continue;
         }
         // Make sure the current directory is within the working directory
         if (strpos($tempDestFolder, $destFolder) === false) {
             continue;
         }
         $finalDestFolders[] = $tempDestFolder;
     }
     asort($finalDestFolders);
     // Create the destination directories.
     foreach ($finalDestFolders as $finalDestFolder) {
         if (!IOHelper::folderExists($finalDestFolder)) {
             if (!IOHelper::createFolder($finalDestFolder)) {
                 Craft::log('Could not create folder ' . $finalDestFolder . ' while unzipping: ' . $srcZip, LogLevel::Error);
                 return false;
             }
         }
     }
     unset($finalDestFolders);
     // Extract the files from the zip
     foreach ($zipFiles as $zipFile) {
         // folders have already been created.
         if ($zipFile['folder']) {
             continue;
         }
         if (substr($zipFile['filename'], 0, 9) === '__MACOSX/') {
             continue;
         }
         $destFile = $destFolder . '/' . $zipFile['filename'];
         if (!IOHelper::writeToFile($destFile, $zipFile['content'], true, true)) {
             Craft::log('Could not copy the file ' . $destFile . ' while unziping: ' . $srcZip, LogLevel::Error);
             return false;
         }
     }
     return true;
 }

 /**
  * @return bool
  */
 private function _isConfigFolderWritable()
 {
     return IOHelper::isWritable(IOHelper::getFolderName(craft()->path->getLicenseKeyPath()));
 }

 /**
  * @access private
  * @param $match
  * @return string
  */
 private function _normalizeCssUrl($match)
 {
     // ignore root-relative, absolute, and data: URLs
     if (preg_match('/^(\\/|https?:\\/\\/|data:)/', $match[3])) {
         return $match[0];
     }
     $url = IOHelper::getFolderName(craft()->request->getPath()) . $match[3];
     // Make sure this is a resource URL
     $resourceTrigger = craft()->config->get('resourceTrigger');
     $resourceTriggerPos = strpos($url, $resourceTrigger);
     if ($resourceTriggerPos !== false) {
         // Give UrlHelper a chance to add the timestamp
         $path = substr($url, $resourceTriggerPos + strlen($resourceTrigger));
         $url = UrlHelper::getResourceUrl($path);
     }
     return $match[1] . $url . $match[4];
 }

 /**
  * @param bool $fullPath
  * @return mixed
  */
 public function getFolderName($fullPath = true)
 {
     if ($fullPath) {
         if (!$this->_fullFolderName) {
             $this->_fullFolderName = IOHelper::getFolderName($this->getRealPath(), $fullPath);
         }
         return $this->_fullFolderName;
     } else {
         if (!$this->_folderNameOnly) {
             $this->_folderNameOnly = IOHelper::getFolderName($this->getRealPath(), $fullPath);
         }
         return $this->_folderNameOnly;
     }
 }

	/**
	 * @param     $tempFileName
	 * @param     $originalSize
	 * @param     $extension
	 * @param     $minQuality
	 * @param     $maxQuality
	 * @param int $step
	 *
	 * @return bool
	 */
	private function _autoGuessImageQuality($tempFileName, $originalSize, $extension, $minQuality, $maxQuality, $step = 0)
	{
		// Give ourselves some extra time.
		@set_time_limit(30);

		if ($step == 0)
		{
			$tempFileName = IOHelper::getFolderName($tempFileName).IOHelper::getFileName($tempFileName, false).'-temp.'.$extension;
		}

		// Find our target quality by splitting the min and max qualities
		$midQuality = (int)ceil($minQuality + (($maxQuality - $minQuality) / 2));

		// Set the min and max acceptable ranges. .10 means anything between 90% and 110% of the original file size is acceptable.
		$acceptableRange = .10;

		clearstatcache();

		// Generate a new temp image and get it's file size.
		$this->_image->save($tempFileName, $this->_getSaveOptions($midQuality, $extension));
		$newFileSize = IOHelper::getFileSize($tempFileName);

		// If we're on step 10 OR we're within our acceptable range threshold OR midQuality = maxQuality (1 == 1),
		// let's use the current image.
		if ($step == 10 || abs(1 - $originalSize / $newFileSize) < $acceptableRange || $midQuality == $maxQuality)
		{
			clearstatcache();

			// Generate one last time.
			$this->_image->save($tempFileName, $this->_getSaveOptions($midQuality));
			return true;
		}

		$step++;

		if ($newFileSize > $originalSize)
		{
			return $this->_autoGuessImageQuality($tempFileName, $originalSize, $extension, $minQuality, $midQuality, $step);
		}
		// Too much.
		else
		{
			return $this->_autoGuessImageQuality($tempFileName, $originalSize, $extension, $midQuality, $maxQuality, $step);
		}
	}

 /**
  * Stores a value identified by a key in cache. This is the implementation of the method declared in the parent class.
  *
  * @param  string  $key    The key identifying the value to be cached
  * @param  string  $value  The value to be cached
  * @param  integer $expire The number of seconds in which the cached value will expire. 0 means never expire.
  * @return boolean true    If the value is successfully stored into cache, false otherwise
  */
 protected function setValue($key, $value, $expire)
 {
     if (!$this->_gced && mt_rand(0, 1000000) < $this->getGCProbability()) {
         $this->gc();
         $this->_gced = true;
     }
     if ($expire <= 0) {
         $expire = 31536000;
         // 1 year
     }
     $expire += time();
     $cacheFile = $this->getCacheFile($key);
     if ($this->directoryLevel > 0) {
         IOHelper::createFolder(IOHelper::getFolderName($cacheFile), IOHelper::getWritableFolderPermissions());
     }
     if ($this->_originalKey == 'useWriteFileLock') {
         if (IOHelper::writeToFile($cacheFile, $value, true, false, true) !== false) {
             IOHelper::changePermissions($cacheFile, IOHelper::getWritableFilePermissions());
             return IOHelper::touch($cacheFile, $expire);
         } else {
             return false;
         }
     } else {
         if (IOHelper::writeToFile($cacheFile, $value) !== false) {
             IOHelper::changePermissions($cacheFile, IOHelper::getWritableFilePermissions());
             return IOHelper::touch($cacheFile, $expire);
         } else {
             return false;
         }
     }
 }

 /**
  * Creates a new support ticket for the GetHelp widget.
  *
  * @return null
  */
 public function actionSendSupportRequest()
 {
     $this->requirePostRequest();
     craft()->config->maxPowerCaptain();
     $success = false;
     $errors = array();
     $zipFile = null;
     $tempFolder = null;
     $widgetId = craft()->request->getPost('widgetId');
     $namespace = craft()->request->getPost('namespace');
     $namespace = $namespace ? $namespace . '.' : '';
     $getHelpModel = new GetHelpModel();
     $getHelpModel->fromEmail = craft()->request->getPost($namespace . 'fromEmail');
     $getHelpModel->message = trim(craft()->request->getPost($namespace . 'message'));
     $getHelpModel->attachLogs = (bool) craft()->request->getPost($namespace . 'attachLogs');
     $getHelpModel->attachDbBackup = (bool) craft()->request->getPost($namespace . 'attachDbBackup');
     $getHelpModel->attachTemplates = (bool) craft()->request->getPost($namespace . 'attachTemplates');
     $getHelpModel->attachment = UploadedFile::getInstanceByName($namespace . 'attachAdditionalFile');
     if ($getHelpModel->validate()) {
         $user = craft()->userSession->getUser();
         // Add some extra info about this install
         $message = $getHelpModel->message . "\n\n" . "------------------------------\n\n" . 'Craft ' . craft()->getEditionName() . ' ' . craft()->getVersion() . '.' . craft()->getBuild();
         $plugins = craft()->plugins->getPlugins();
         if ($plugins) {
             $pluginNames = array();
             foreach ($plugins as $plugin) {
                 $pluginNames[] = $plugin->getName() . ' ' . $plugin->getVersion() . ' (' . $plugin->getDeveloper() . ')';
             }
             $message .= "\nPlugins: " . implode(', ', $pluginNames);
         }
         $requestParamDefaults = array('sFirstName' => $user->getFriendlyName(), 'sLastName' => $user->lastName ? $user->lastName : 'Doe', 'sEmail' => $getHelpModel->fromEmail, 'tNote' => $message);
         $requestParams = $requestParamDefaults;
         $hsParams = array('helpSpotApiURL' => 'https://support.pixelandtonic.com/api/index.php');
         try {
             if ($getHelpModel->attachLogs || $getHelpModel->attachDbBackup) {
                 if (!$zipFile) {
                     $zipFile = $this->_createZip();
                 }
                 if ($getHelpModel->attachLogs && IOHelper::folderExists(craft()->path->getLogPath())) {
                     // Grab it all.
                     $logFolderContents = IOHelper::getFolderContents(craft()->path->getLogPath());
                     foreach ($logFolderContents as $file) {
                         // Make sure it's a file.
                         if (IOHelper::fileExists($file)) {
                             Zip::add($zipFile, $file, craft()->path->getStoragePath());
                         }
                     }
                 }
                 if ($getHelpModel->attachDbBackup && IOHelper::folderExists(craft()->path->getDbBackupPath())) {
                     // Make a fresh database backup of the current schema/data. We want all data from all tables
                     // for debugging.
                     craft()->db->backup();
                     $backups = IOHelper::getLastModifiedFiles(craft()->path->getDbBackupPath(), 3);
                     foreach ($backups as $backup) {
                         if (IOHelper::getExtension($backup) == 'sql') {
                             Zip::add($zipFile, $backup, craft()->path->getStoragePath());
                         }
                     }
                 }
             }
             if ($getHelpModel->attachment) {
                 // If we don't have a zip file yet, create one now.
                 if (!$zipFile) {
                     $zipFile = $this->_createZip();
                 }
                 $tempFolder = craft()->path->getTempPath() . StringHelper::UUID() . '/';
                 if (!IOHelper::folderExists($tempFolder)) {
                     IOHelper::createFolder($tempFolder);
                 }
                 $tempFile = $tempFolder . $getHelpModel->attachment->getName();
                 $getHelpModel->attachment->saveAs($tempFile);
                 // Make sure it actually saved.
                 if (IOHelper::fileExists($tempFile)) {
                     Zip::add($zipFile, $tempFile, $tempFolder);
                 }
             }
             if ($getHelpModel->attachTemplates) {
                 // If we don't have a zip file yet, create one now.
                 if (!$zipFile) {
                     $zipFile = $this->_createZip();
                 }
                 if (IOHelper::folderExists(craft()->path->getLogPath())) {
                     // Grab it all.
                     $templateFolderContents = IOHelper::getFolderContents(craft()->path->getSiteTemplatesPath());
                     foreach ($templateFolderContents as $file) {
                         // Make sure it's a file.
                         if (IOHelper::fileExists($file)) {
                             $templateFolderName = IOHelper::getFolderName(craft()->path->getSiteTemplatesPath(), false);
                             $siteTemplatePath = craft()->path->getSiteTemplatesPath();
                             $tempPath = substr($siteTemplatePath, 0, strlen($siteTemplatePath) - strlen($templateFolderName) - 1);
                             Zip::add($zipFile, $file, $tempPath);
                         }
                     }
                 }
             }
//.........这里部分代码省略.........

 /**
  * @static
  * @param bool $fetch
  * @return array
  */
 public static function getAlerts($path = null, $fetch = false)
 {
     $alerts = array();
     $user = craft()->userSession->getUser();
     if (!$user) {
         return $alerts;
     }
     if (craft()->updates->isUpdateInfoCached() || $fetch) {
         // Fetch the updates regardless of whether we're on the Updates page or not,
         // because the other alerts are relying on cached Elliott info
         $updateModel = craft()->updates->getUpdates();
         if ($path != 'updates' && $user->can('performUpdates')) {
             if (!empty($updateModel->app->releases)) {
                 if (craft()->updates->criticalCraftUpdateAvailable($updateModel->app->releases)) {
                     $alerts[] = Craft::t('There’s a critical Craft update available.') . ' <a class="go" href="' . UrlHelper::getUrl('updates') . '">' . Craft::t('Go to Updates') . '</a>';
                 }
             }
         }
         // Domain mismatch?
         $licenseKeyStatus = craft()->et->getLicenseKeyStatus();
         if ($licenseKeyStatus == LicenseKeyStatus::MismatchedDomain) {
             $licensedDomain = craft()->et->getLicensedDomain();
             $licenseKeyPath = craft()->path->getLicenseKeyPath();
             $licenseKeyFile = IOHelper::getFolderName($licenseKeyPath, false) . '/' . IOHelper::getFileName($licenseKeyPath);
             $message = Craft::t('The license located at {file} belongs to {domain}.', array('file' => $licenseKeyFile, 'domain' => '<a href="http://' . $licensedDomain . '" target="_blank">' . $licensedDomain . '</a>'));
             // Can they actually do something about it?
             if ($user->admin) {
                 $action = '<a class="domain-mismatch">' . Craft::t('Transfer it to this domain?') . '</a>';
             } else {
                 $action = Craft::t('Please notify one of your site’s admins.');
             }
             $alerts[] = $message . ' ' . $action;
         }
         // Unlicensed packages?
         if ($path != 'settings/packages') {
             $licensedPackages = craft()->et->getLicensedPackages();
             $packageTrials = craft()->et->getPackageTrials();
             // Could be false if not cached
             if (is_array($licensedPackages)) {
                 // Look for any unlicensed licenses
                 $unlicensedPackages = array();
                 foreach (Craft::getPackages() as $package) {
                     if (!in_array($package, $licensedPackages)) {
                         // Make sure it's not in trial
                         if (!is_array($packageTrials) || !in_array($package, array_keys($packageTrials))) {
                             $unlicensedPackages[] = $package;
                         }
                     }
                 }
                 if ($unlicensedPackages) {
                     if (count($unlicensedPackages) == 1) {
                         $message = Craft::t('The {package} package is installed, but it’s not licensed.', array('package' => Craft::t($unlicensedPackages[0])));
                     } else {
                         $message = Craft::t('You have multiple unlicensed packages installed.');
                     }
                     // Can they actually do something about it?
                     if ($user->admin) {
                         $action = '<a class="go" href="' . UrlHelper::getUrl('settings/packages') . '">' . Craft::t('Manage packages') . '</a>';
                     } else {
                         $action = Craft::t('Please notify one of your site’s admins.');
                     }
                     $alerts[] = $message . ' ' . $action;
                 }
             }
             if ($packageTrials && $user->admin && !$user->hasShunned('packageTrialAlert')) {
                 $expiringTrials = array();
                 $currentTime = DateTimeHelper::currentUTCDateTime();
                 $nextWeek = $currentTime->add(new DateInterval('P1W'))->getTimestamp();
                 // See if there are any package trials that expire in less than a week
                 foreach (Craft::getPackages() as $package) {
                     if (!empty($packageTrials[$package])) {
                         if ($packageTrials[$package] < $nextWeek) {
                             $expiringTrials[] = $package;
                         }
                     }
                 }
                 if ($expiringTrials) {
                     if (count($expiringTrials) == 1) {
                         $message = Craft::t('Your {package} trial is expiring soon.', array('package' => Craft::t($expiringTrials[0])));
                     } else {
                         $message = Craft::t('You have multiple package trials expiring soon.');
                     }
                     $action1 = '<a class="shun:packageTrialAlert">' . Craft::t('Remind me later') . '</a>';
                     $action2 = '<a class="go" href="' . UrlHelper::getUrl('settings/packages') . '">' . Craft::t('manage packages') . '</a>';
                     $alerts[] = $message . ' ' . $action1 . ' ' . Craft::t('or') . ' ' . $action2;
                 }
             }
         }
     }
     return $alerts;
 }