PHP Util::concatPath方法代码示例

 public function get($scope, $name)
 {
     $scope = $this->sanitizeInput($scope);
     $name = $this->sanitizeInput($name);
     if (isset($this->changedData[$scope][$name])) {
         return Json::encode($this->changedData[$scope][$name]);
     }
     $fileFullPath = Util::concatPath($this->getLayoutPath($scope, true), 'portal/' . $name . '.json');
     if (!file_exists($fileFullPath)) {
         $fileFullPath = Util::concatPath($this->getLayoutPath($scope), 'portal/' . $name . '.json');
     }
     if (!file_exists($fileFullPath)) {
         $fileFullPath = Util::concatPath($this->getLayoutPath($scope, true), $name . '.json');
     }
     if (!file_exists($fileFullPath)) {
         $fileFullPath = Util::concatPath($this->getLayoutPath($scope), $name . '.json');
     }
     if (!file_exists($fileFullPath)) {
         $defaultPath = $this->params['defaultsPath'];
         $fileFullPath = Util::concatPath(Util::concatPath($defaultPath, 'layouts'), $name . '.json');
         if (!file_exists($fileFullPath)) {
             return false;
         }
     }
     return $this->getFileManager()->getContents($fileFullPath);
 }

 protected function restoreFiles()
 {
     $GLOBALS['log']->info('Installer: Restore previous files.');
     $backupPath = $this->getPath('backupPath');
     $backupFilePath = Util::concatPath($backupPath, self::FILES);
     $backupFileList = $this->getRestoreFileList();
     $copyFileList = $this->getCopyFileList();
     $deleteFileList = array_diff($copyFileList, $backupFileList);
     $res = $this->copy($backupFilePath, '', true);
     $res &= $this->getFileManager()->remove($deleteFileList, null, true);
     if ($res) {
         $this->getFileManager()->removeInDir($backupPath, true);
     }
     return $res;
 }

 /**
  * Get and merge hook data by checking the files exist in $hookDirs
  *
  * @param array $hookDirs - it can be an array('Espo/Hooks', 'Espo/Custom/Hooks', 'Espo/Modules/Crm/Hooks')
  *
  * @return array
  */
 protected function getHookData($hookDirs)
 {
     if (is_string($hookDirs)) {
         $hookDirs = (array) $hookDirs;
     }
     $hooks = array();
     foreach ($hookDirs as $hookDir) {
         if (file_exists($hookDir)) {
             $fileList = $this->getFileManager()->getFileList($hookDir, 1, '\\.php$', 'file');
             foreach ($fileList as $scopeName => $hookFiles) {
                 $hookScopeDirPath = Util::concatPath($hookDir, $scopeName);
                 $scopeHooks = array();
                 foreach ($hookFiles as $hookFile) {
                     $hookFilePath = Util::concatPath($hookScopeDirPath, $hookFile);
                     $className = Util::getClassName($hookFilePath);
                     foreach ($this->hookList as $hookName) {
                         if (method_exists($className, $hookName)) {
                             $scopeHooks[$hookName][$className::$order][] = $className;
                         }
                     }
                 }
                 //sort hooks by order
                 foreach ($scopeHooks as $hookName => $hookList) {
                     ksort($hookList);
                     $sortedHookList = array();
                     foreach ($hookList as $hookDetails) {
                         $sortedHookList = array_merge($sortedHookList, $hookDetails);
                     }
                     $hooks[$scopeName][$hookName] = isset($hooks[$scopeName][$hookName]) ? array_merge($hooks[$scopeName][$hookName], $sortedHookList) : $sortedHookList;
                 }
             }
         }
     }
     return $hooks;
 }

 public function testConcatPath()
 {
     $result = Util::fixPath('dir1/dir2/file1.json');
     $this->assertEquals($result, Util::concatPath('dir1/dir2', 'file1.json'));
     $result = Util::fixPath('dir1/dir2/file1.json');
     $this->assertEquals($result, Util::concatPath('dir1/dir2/', 'file1.json'));
     $result = Util::fixPath('dir1/dir2/file1.json');
     $this->assertEquals($result, Util::concatPath('dir1/dir2/file1.json'));
     $input = array('dir1/dir2', 'file1.json');
     $result = Util::fixPath('dir1/dir2/file1.json');
     $this->assertEquals($result, Util::concatPath($input));
     $input = array('dir1/', 'dir2', 'file1.json');
     $result = Util::fixPath('dir1/dir2/file1.json');
     $this->assertEquals($result, Util::concatPath($input));
 }

 protected function initFieldTypes()
 {
     foreach ($this->fieldTypePaths as $path) {
         $typeList = $this->getFileManager()->getFileList($path, false, '\\.php$');
         if ($typeList !== false) {
             foreach ($typeList as $name) {
                 $typeName = preg_replace('/\\.php$/i', '', $name);
                 $dbalTypeName = strtolower($typeName);
                 $filePath = Util::concatPath($path, $typeName);
                 $class = Util::getClassName($filePath);
                 if (!Type::hasType($dbalTypeName)) {
                     Type::addType($dbalTypeName, $class);
                 } else {
                     Type::overrideType($dbalTypeName, $class);
                 }
                 $dbTypeName = method_exists($class, 'getDbTypeName') ? $class::getDbTypeName() : $dbalTypeName;
                 $this->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping($dbTypeName, $dbalTypeName);
             }
         }
     }
 }

 /**
  * Remove items (files or directories)
  *
  * @param  string | array $items
  * @param  string $dirPath
  * @return boolean
  */
 public function remove($items, $dirPath = null, $removeEmptyDirs = false)
 {
     if (!is_array($items)) {
         $items = (array) $items;
     }
     $permissionDeniedList = array();
     foreach ($items as $item) {
         if (isset($dirPath)) {
             $item = Utils\Util::concatPath($dirPath, $item);
         }
         if (!is_writable($item)) {
             $permissionDeniedList[] = $item;
         } else {
             if (!is_writable(dirname($item))) {
                 $permissionDeniedList[] = dirname($item);
             }
         }
     }
     if (!empty($permissionDeniedList)) {
         $betterPermissionList = $this->getPermissionUtils()->arrangePermissionList($permissionDeniedList);
         throw new Error("Permission denied for <br>" . implode(", <br>", $betterPermissionList));
     }
     $result = true;
     foreach ($items as $item) {
         if (isset($dirPath)) {
             $item = Utils\Util::concatPath($dirPath, $item);
         }
         if (is_dir($item)) {
             $result &= $this->removeInDir($item, true);
         } else {
             $result &= $this->removeFile($item);
         }
         if ($removeEmptyDirs) {
             $result &= $this->removeEmptyDirs($item);
         }
     }
     return (bool) $result;
 }

 /**
  * Helpful method for get content from files for unite Files
  *
  * @param string | array $paths
  * @param string | array() $defaults - It can be a string like ["metadata","layouts"] OR an array with default values
  *
  * @return array
  */
 protected function unifyGetContents($paths, $defaults)
 {
     $fileContent = $this->getFileManager()->getContents($paths);
     $decoded = Utils\Json::getArrayData($fileContent, null);
     if (!isset($decoded)) {
         $GLOBALS['log']->emergency('Syntax error in ' . Utils\Util::concatPath($paths));
         return array();
     }
     return $decoded;
 }

 protected function getRestoreFileList()
 {
     if (!isset($this->data['restoreFileList'])) {
         $packagePath = $this->getPackagePath();
         $filesPath = Util::concatPath($packagePath, self::FILES);
         if (!file_exists($filesPath)) {
             $this->unzipArchive($packagePath);
         }
         $this->data['restoreFileList'] = $this->getFileManager()->getFileList($filesPath, true, '', true, true);
     }
     return $this->data['restoreFileList'];
 }

 public function getManifest()
 {
     if (!isset($this->data['manifest'])) {
         $packagePath = $this->getPackagePath();
         $manifestPath = Util::concatPath($packagePath, $this->manifestName);
         if (!file_exists($manifestPath)) {
             $this->throwErrorAndRemovePackage('It\'s not an Installation package.');
         }
         $manifestJson = $this->getFileManager()->getContents($manifestPath);
         $this->data['manifest'] = Json::decode($manifestJson, true);
         if (!$this->data['manifest']) {
             $this->throwErrorAndRemovePackage('Syntax error in manifest.json.');
         }
         if (!$this->checkManifest($this->data['manifest'])) {
             $this->throwErrorAndRemovePackage('Unsupported package.');
         }
     }
     return $this->data['manifest'];
 }

 public function getSetupMessage()
 {
     $language = $this->getContainer()->get('language');
     $OS = $this->getSystemUtil()->getOS();
     $phpBin = $this->getSystemUtil()->getPhpBin();
     $cronFile = Util::concatPath($this->getSystemUtil()->getRootDir(), $this->cronFile);
     $desc = $language->translate('cronSetup', 'options', 'ScheduledJob');
     $message = isset($desc[$OS]) ? $desc[$OS] : $desc['default'];
     $command = isset($this->cronSetup[$OS]) ? $this->cronSetup[$OS] : $this->cronSetup['default'];
     $command = str_replace(array('{PHP-BIN-DIR}', '{CRON-FILE}'), array($phpBin, $cronFile), $command);
     return array('message' => $message, 'command' => $command);
 }

 /**
  * Remove items (files or directories)
  *
  * @param  string | array $items
  * @param  string $dirPath
  * @return boolean
  */
 public function remove($items, $dirPath = null)
 {
     if (!is_array($items)) {
         $items = (array) $items;
     }
     $result = true;
     foreach ($items as $item) {
         if (isset($dirPath)) {
             $item = Utils\Util::concatPath($dirPath, $item);
         }
         if (is_dir($item)) {
             $result = $this->removeInDir($item, true);
         } else {
             $result = $this->removeFile($item);
         }
     }
     return $result;
 }

 /**
  * Helpful method for get content from files for unite Files
  *
  * @param string | array $paths
  * @param string | array() $defaults - It can be a string like ["metadata","layouts"] OR an array with default values
  *
  * @return array
  */
 protected function unifyGetContents($paths, $defaults)
 {
     $fileContent = $this->getFileManager()->getContents($paths);
     $decoded = Utils\Json::getArrayData($fileContent);
     if (empty($decoded) && !is_array($decoded)) {
         $GLOBALS['log']->emergency('Syntax error or empty file - ' . Utils\Util::concatPath($folderPath, $fileName));
     } else {
         //Default values
         if (is_string($defaults) && !empty($defaults)) {
             $defType = $defaults;
             unset($defaults);
             $name = $this->getFileManager()->getFileName($fileName, '.json');
             $defaults = $this->loadDefaultValues($name, $defType);
         }
         $mergedValues = Utils\Util::merge($defaults, $decoded);
         //END: Default values
         return $mergedValues;
     }
     return array();
 }

 protected function getClassNameHash($dirs)
 {
     if (is_string($dirs)) {
         $dirs = (array) $dirs;
     }
     $data = array();
     foreach ($dirs as $dir) {
         if (file_exists($dir)) {
             $fileList = $this->getFileManager()->getFileList($dir, false, '\\.php$', 'file');
             foreach ($fileList as $file) {
                 $filePath = Util::concatPath($dir, $file);
                 $className = Util::getClassName($filePath);
                 $fileName = $this->getFileManager()->getFileName($filePath);
                 $data[$fileName] = $className;
             }
         }
     }
     return $data;
 }

 protected function getClassNameHash($dirs)
 {
     if (is_string($dirs)) {
         $dirs = (array) $dirs;
     }
     $data = array();
     foreach ($dirs as $dir) {
         if (file_exists($dir)) {
             $fileList = $this->getFileManager()->getFileList($dir, false, '\\.php$', true);
             foreach ($fileList as $file) {
                 $filePath = Util::concatPath($dir, $file);
                 $className = Util::getClassName($filePath);
                 $fileName = $this->getFileManager()->getFileName($filePath);
                 $scopeName = ucfirst($fileName);
                 $normalizedScopeName = Util::normilizeScopeName($scopeName);
                 if (empty($this->allowedMethods)) {
                     $data[$normalizedScopeName] = $className;
                     continue;
                 }
                 foreach ($this->allowedMethods as $methodName) {
                     if (method_exists($className, $methodName)) {
                         $data[$normalizedScopeName] = $className;
                     }
                 }
             }
         }
     }
     return $data;
 }