protected function setUp()
{
MockManager::activateWebsiteMock();
MockManager::activatePageMock();
parent::setUp();
FS::createDirIfNotExists($this->getWorkingDirectory());
ConfigHelper::disableDefaultPageType();
}
/**
* @param string|null $baseUri
*/
public function __construct($baseUri = null)
{
$davConfig = Registry::getConfig()->dav;
$this->baseUri = $baseUri;
$this->rootDirectory = $davConfig->directory;
$tmpDirectory = $davConfig->temp_dir;
FS::createDirIfNotExists($tmpDirectory);
$this->lockFilePath = FS::joinPath($tmpDirectory, 'davlocks');
$this->initServer();
}
/**
* @param string $fromWebsiteId
* @param string $toWebsiteId
*/
public function copyToNewWebsite($fromWebsiteId, $toWebsiteId)
{
$moduleConfig = Registry::getConfig()->item->data;
$dataDirectory = $moduleConfig->directory;
$sourceDirectory = FS::joinPath($dataDirectory, $fromWebsiteId, self::SUBDIR_LOCAL);
$destinationDirectory = FS::joinPath($dataDirectory, $toWebsiteId, self::SUBDIR_LOCAL);
FS::createDirIfNotExists($destinationDirectory, true);
if (is_dir($sourceDirectory)) {
FS::copyDir($sourceDirectory, $destinationDirectory);
}
$this->getDao()->resetCache();
}
/**
* Haendelt den Import einer Datei
*
* @param string $uploadFilename
* @param string $websiteId
* @param string $allowedType
*
* @return array
* @throws \Cms\Exception
*/
public function importUploadFile($uploadFilename, $websiteId, $allowedType)
{
$config = Registry::getConfig();
$importDirectory = $config->import->directory;
FS::createDirIfNotExists($importDirectory);
$import = TransferFactory::getAdapter();
$imports = $import->getFileInfo();
if (isset($config->import->uploadFile) && isset($config->import->uploadFile->doNotRename)) {
$renameUploadFile = new Boolean($config->import->uploadFile->doNotRename);
$renameUploadFile = !$renameUploadFile->getValue();
} else {
$renameUploadFile = true;
}
if ($renameUploadFile) {
$uploadFilename = basename($uploadFilename, '.zip') . '.P' . time() . '_' . rand(100000, 999999) . '.zip';
}
$import->addFilter('Rename', $uploadFilename);
$import->setDestination($importDirectory);
$import->receive();
$importFile = $importDirectory . DIRECTORY_SEPARATOR . $uploadFilename;
return $this->importFile($importFile, $websiteId, $allowedType);
}
/**
* @param $importFilename
*
* @return string
*/
protected function createImportFile($importFilename)
{
$config = Registry::getConfig();
$importFilePath = FS::joinPath($config->test->files->directory, 'test_exports', $importFilename);
$fakedImportFile = FS::joinPath($config->import->directory, $importFilename);
$unzipDirectory = str_replace('.zip', '', $fakedImportFile);
$assertionMessage = sprintf("Test import file '%s' not exists", $importFilePath);
$this->assertFileExists($importFilePath, $assertionMessage);
// Add fake upload file and unzip directory to delete lists
$this->filesToDeleteAtTearDown[] = $fakedImportFile;
$this->directoriesToDeleteAtTearDown[] = $unzipDirectory;
FS::copyFile($importFilePath, $fakedImportFile);
FS::createDirIfNotExists($unzipDirectory, true);
return $importFilePath;
}
/**
* Creates the writeable data folders
*/
protected function createDataFileFolders()
{
// create dirs
$fileDirs = array('data', FS::joinPath('data', 'theme'), FS::joinPath('data', 'live'), 'builds', 'screens_cache', 'screens', 'publishing', 'websites', 'media', 'media_cache', 'var', FS::joinPath('var', 'logs'), FS::joinPath('var', 'import'), FS::joinPath('var', 'export'), FS::joinPath('var', 'creator'), FS::joinPath('var', 'fts_index'), FS::joinPath('var', 'import-latch'), FS::joinPath('var', 'session'), FS::joinPath('var', 'screenshot'), FS::joinPath('var', 'publish'));
foreach ($fileDirs as $d) {
FS::createDirIfNotExists(FS::joinPath(CMS_PATH, $d), true, 0750);
}
}
/**
* Creates the target directory for the theming files
*/
protected function createTargetDirectory()
{
FS::createDirIfNotExists($this->targetPath, true);
}
/**
* @param string $srcDirectory
* @param string $destDirectory
*/
protected function copyModuleFiles($srcDirectory, $destDirectory)
{
FS::createDirIfNotExists($destDirectory, true);
if (!is_dir($srcDirectory)) {
return;
}
foreach (new \DirectoryIterator($srcDirectory) as $fileInfo) {
if ($fileInfo->isDot()) {
continue;
}
$this->copyModuleFile($srcDirectory, $destDirectory, $fileInfo->getFilename());
}
}
/**
* @param string $websiteId
* @param bool $checkConflict
* @param array $overwriteIds
*
* @return array
*/
protected function importPackages($websiteId, $checkConflict = false, array $overwriteIds = array())
{
$importedPackages = array();
$conflictingPackageIds = array();
$packageService = $this->getPackageService();
if ($checkConflict && isset($this->currentConflictItems['packages'])) {
$conflictingPackageIds = array_keys($this->currentConflictItems['packages']);
}
foreach ($this->currentImportPackageInfo as $packageId => $packageInfo) {
// check if import of the package is allowed
if (!$this->itemImportAllowed($packageId, $conflictingPackageIds, $overwriteIds)) {
continue;
}
$localDirectory = $packageService->getDirectoryFormImportingLocalPackages($websiteId);
$localPackageDirectory = FS::joinPath($localDirectory, $packageId);
if (file_exists($localPackageDirectory)) {
FS::rmdir($localPackageDirectory);
}
FS::createDirIfNotExists($localPackageDirectory, true);
FS::copyDir($packageInfo['directory'], $localPackageDirectory);
$importedPackages[] = array('id' => $packageId, 'name' => $packageInfo['name']);
}
// ensure that the imported packages will be (re)loaded
$packageService->resetCache();
return $importedPackages;
}
/**
* @param string $id
*/
private function createWebsiteDirectories($id)
{
$baseDataDirectory = realpath(Registry::getConfig()->item->data->directory);
if (empty($baseDataDirectory)) {
Registry::getLogger()->log(__METHOD__, __LINE__, 'failed to calculate base data directory: ' . $baseDataDirectory, SbLog::ERR);
return;
}
$itemDataDirectory = FS::joinPath($baseDataDirectory, $id);
if (empty($itemDataDirectory) || is_dir($itemDataDirectory)) {
return;
}
try {
FS::createDirIfNotExists($itemDataDirectory, true);
} catch (\Exception $logOnly) {
Registry::getLogger()->log(__METHOD__, __LINE__, $logOnly->getMessage(), SbLog::ERR);
}
}
/**
* @param string $websiteId
* @param string $publishingId
* @param string $buildFilePath
* @return string path to publishing file
*/
private function copyBuildToPublishingDirectory($websiteId, $publishingId, $buildFilePath)
{
$config = Registry::getConfig();
$publishingDirectory = FS::joinPath($config->publisher->data->directory, $websiteId);
FS::createDirIfNotExists($publishingDirectory, true);
$publishingFilePath = FS::joinPath($publishingDirectory, $publishingId . '.zip');
FS::copyFile($buildFilePath, $publishingFilePath);
return $publishingFilePath;
}
/**
* @param string $websiteId
*/
private function createWebsiteBuildsDirectory($websiteId)
{
$websiteBuildsDirectory = $this->getWebsiteBuildsDirectory($websiteId);
FS::createDirIfNotExists($websiteBuildsDirectory, true);
}
/**
* @param string $exportName
* @return boolean
*/
private function createExportDirectory($exportName)
{
$this->currentExportName = md5($exportName);
$this->currentExportDirectory = FS::joinPath($this->exportDirectory, $this->currentExportName);
if (is_dir($this->currentExportDirectory)) {
$this->deleteLeftoverExport();
}
return FS::createDirIfNotExists($this->currentExportDirectory, true, 0750);
}
/**
* @param $websiteId
* @param $pageOrTemplateId
*
* @return FileBasedJsonCache
*/
protected function createCache($websiteId, $pageOrTemplateId)
{
$config = Registry::getConfig();
$dataPath = $config->item->data->directory;
$cachePath = FS::joinPath($dataPath, $websiteId, 'cache', $pageOrTemplateId);
FS::createDirIfNotExists($cachePath, true);
return new FileBasedJsonCache($cachePath);
}
/**
* @param string $liveDirectory
* @param string $srcDirectory
* @param array $writeableDirectories
* @param array $cacheDirectories
* @param string $subDirectory
*
* @throws CmsException
*/
protected function updateLive($liveDirectory, $srcDirectory, $writeableDirectories, $cacheDirectories, $subDirectory = '')
{
if (!is_dir($srcDirectory)) {
throw new CmsException(902, __METHOD__, __LINE__, array('msg' => sprintf('source directory %s not exists', $srcDirectory)));
}
// create live directory
if (!is_dir($liveDirectory)) {
FS::createDirIfNotExists($liveDirectory, true, 0755);
}
// set directory rights
if (!empty($subDirectory) && $this->isInsideDirectory($subDirectory, $writeableDirectories)) {
// writeable
FS::chmod($liveDirectory, 0777);
} else {
FS::chmod($liveDirectory, 0755);
}
// get info of the directories
$liveDirInfo = $this->getDirectoryAsArray($liveDirectory);
$srcDirInfo = $this->getDirectoryAsArray($srcDirectory);
// delete live directories
foreach ($liveDirInfo['directories'] as $liveSubDirectoryName => $liveSubDirectory) {
if ($this->isInsideDirectory($subDirectory . $liveSubDirectoryName, $writeableDirectories)) {
FS::chmod($liveSubDirectory, 0777);
continue;
}
if (!isset($srcDirInfo['directories'][$liveSubDirectoryName])) {
FS::rmdir($liveDirectory);
}
}
// delete live files
foreach ($liveDirInfo['files'] as $liveFileName => $liveFilePathName) {
if ($this->isInsideDirectory($subDirectory . $liveFileName, $writeableDirectories)) {
FS::chmod($liveFilePathName, 0777);
continue;
}
if (!isset($srcDirInfo['files'][$liveFileName])) {
FS::rmFile($liveFilePathName);
}
}
// copy source directories
foreach ($srcDirInfo['directories'] as $srcSubDirectoryName => $srcSubDirectory) {
$subDirPathName = $subDirectory . $srcSubDirectoryName . DIRECTORY_SEPARATOR;
$newLiveDirectory = FS::joinPath($liveDirectory, $srcSubDirectoryName);
$this->updateLive($newLiveDirectory, $srcSubDirectory, $writeableDirectories, $cacheDirectories, $subDirPathName);
}
// copy source files
foreach ($srcDirInfo['files'] as $srcFileName => $srcFilePathName) {
$newLiveFilePathName = FS::joinPath($liveDirectory, $srcFileName);
FS::copyFile($srcFilePathName, $newLiveFilePathName);
if ($this->isInsideDirectory($subDirectory . $srcFileName, $writeableDirectories)) {
FS::chmod($newLiveFilePathName, 0777);
} else {
FS::chmod($newLiveFilePathName, 0755);
}
}
}
/**
* @param string $moduleDir
*/
protected function createModuleDirectoriesIfNotExits($moduleDir)
{
FS::createDirIfNotExists($moduleDir, true);
FS::createDirIfNotExists(FS::joinPath($moduleDir, self::SUBDIR_DATA));
FS::createDirIfNotExists(FS::joinPath($moduleDir, self::SUBDIR_ASSETS));
}
/**
* @param string $websiteId
* @param string $id
* @param string $type
* @param string $originFile
* @param string $relativeDir
* @param array $option
* @return string
*/
protected function modifyScreenhot($websiteId, $id, $type, $originFile, $relativeDir, $options)
{
$width = (int) $options['width'];
$height = (int) $options['height'];
$cacheFilePath = FS::joinPath(Registry::getConfig()->screens->cache->directory, $relativeDir, $id);
$cacheFile = FS::joinPath($cacheFilePath, sprintf("%dx%d.%s", $width, $height, Registry::getConfig()->screens->filetype));
if (file_exists($cacheFile) && $this->isScreenshotFileValid($cacheFile, $type, $id, $websiteId)) {
return $cacheFile;
}
FS::createDirIfNotExists($cacheFilePath, true);
// Breite und Hoehe fuer crop berechnen
list($originWidth, $originHeight) = getimagesize($originFile);
$widthFaktor = $originWidth / $width;
$heightFaktor = $originHeight / $height;
if ($widthFaktor < $heightFaktor) {
$cropWidth = (int) $originWidth;
$cropHeight = (int) ($widthFaktor * $height);
} else {
$cropWidth = (int) ($heightFaktor * $width);
$cropHeight = (int) $originHeight;
}
$bildBearbeitung = $this->getImageAdapter();
$bildBearbeitung->setFile($originFile);
$bildBearbeitung->crop(array('width' => $cropWidth, 'height' => $cropHeight, 'x' => 0, 'y' => 0));
$bildBearbeitung->resize(array('width' => $width, 'height' => $height));
$bildBearbeitung->quality(array('quality' => 100));
if (!$bildBearbeitung->save($cacheFile)) {
return;
}
return $cacheFile;
}
protected function copyLegacyClasses()
{
// copy legacy render files
$serverDirectory = $this->getServerDirectory();
FS::createDirIfNotExists($serverDirectory, true);
$srcRenderDirectory = realpath(FS::joinPath(APPLICATION_PATH, '..', 'library', 'Dual'));
$destRenderDirector = FS::joinPath($serverDirectory, 'library', 'Dual');
try {
FS::createDirIfNotExists($destRenderDirector, true);
FS::copyDir($srcRenderDirectory, $destRenderDirector);
} catch (\Exception $e) {
$this->addError('Error at copy legacy render classes', $e);
}
}
