public function createFileNode(Element $parentElement, $desiredFilename, $workingFilePath, StorageFacilityFile $preconfiguredFile = null)
 {
     if (empty($desiredFilename)) {
         $desiredFilename = $this->filenameFromBasename(basename($workingFilePath));
     }
     $path = pathinfo($workingFilePath);
     $ext = !empty($path['extension']) ? strtolower($path['extension']) : '';
     if (in_array(strtolower($ext), array_map("strtolower", $this->mediaRestrictedExtensions))) {
         throw new Exception('Cannot add file with restricted extension [' . $ext . ']');
     }
     list($storageFacility, $sfParams) = $this->deriveStorageFacility($parentElement);
     $element = $this->NodeRefService->oneFromAspect('@files')->getElement();
     $file = $preconfiguredFile !== null ? $preconfiguredFile : new StorageFacilityFile();
     $file->setId($storageFacility->findUniqueFileID($sfParams, $desiredFilename));
     $file->setLocalPath($workingFilePath);
     $file = $storageFacility->putFile($sfParams, $file);
     list($width, $height) = ImageUtils::getImageDimensions($file->getLocalPath());
     $mimetype = FileSystemUtils::getMimetype($file->getExtension());
     //CREATE FILE NODE & SAVE
     $nodeRef = new NodeRef($element, SlugUtils::createSlug($file->getId()));
     $nodeRef = $this->NodeService->generateUniqueNodeRef($nodeRef, null, true);
     $node = $nodeRef->generateNode();
     $this->NodeMapper->defaultsOnNode($node);
     $node->Title = $file->getId();
     $node->setMeta('#url', $file->getURL());
     //        $node->setMeta('#path',$file->getLocalPath());
     $node->setMeta('#mimetype', $mimetype);
     $node->setMeta('#size', filesize($file->getLocalPath()));
     $node->setMeta('#width', $width);
     $node->setMeta('#height', $height);
     $node->setMeta('#parent-element', $parentElement->Slug);
     $this->NodeService->add($node);
     return $node;
 }
Пример #2
0
 public static function getInstance()
 {
     if (!self::$fileSystemUtils) {
         self::$fileSystemUtils = new FileSystemUtils();
         return self::$fileSystemUtils;
     }
     return self::$fileSystemUtils;
 }
Пример #3
0
 public function testFixtures()
 {
     $this->createFixtures();
     $directories = FileSystemUtils::listDirectories($this->workDir . '/.composer/global');
     $this->assertEquals('testorg', implode(',', $directories));
     $directories = FileSystemUtils::listDirectories($this->workDir . '/.composer/global/testorg');
     $this->assertEquals('testproject', implode(',', $directories));
     $projects = FileSystemUtils::allInstalledProjectsInBaseDir($this->workDir . '/.composer/global');
     $this->assertEquals('testorg/testproject', implode(',', $projects));
 }
Пример #4
0
 /**
  * Run our command. Set up the environment, as needed, ensuring that
  * it is restored at the end of the run.
  */
 public function run($stdoutFile = '')
 {
     $commandString = $this->getCommandString();
     // print ">> $commandString\n";
     $origEnv = $this->env->apply($this->env);
     $origDir = FileSystemUtils::applyDir($this->dir);
     $exitCode = static::runCommand($commandString, $stdoutFile);
     $origEnv->apply();
     FileSystemUtils::applyDir($origDir);
     return $exitCode;
 }
Пример #5
0
 public function transferTo($filename)
 {
     if (!$this->isEmpty() && is_uploaded_file($this->tempName)) {
         if (@FileSystemUtils::safeCopy($this->tempName, $filename)) {
             return true;
         }
         if (@move_uploaded_file($this->tempName, $filename)) {
             return true;
         }
     }
     return FALSE;
 }
 /**
  * This function copies the file from the local path (specified in the {@link $file}) to the generated storage
  * path; creating any directories as needed.  The public URL will be set on the {@link $file} upon successful
  * persistence to the filesystem.
  *
  * @param Site                $site  Site used to determine storage location
  * @param StorageFacilityFile &$file File to store
  *
  * @return StorageFacilityFile Fully-resolved and stored file, has URL and id
  *                              set appropriately to reference the stored file later
  * @throws StorageFacilityException upon failure
  */
 public function putFile(StorageFacilityParams $params, StorageFacilityFile &$file)
 {
     $storagePath = $this->generateStoragePath($params, $file->getId());
     //        $this->createDirectory($storagePath);
     if (is_file($file->getLocalPath())) {
         try {
             FileSystemUtils::safeCopy($file->getLocalPath(), $storagePath);
         } catch (Exception $e) {
             throw new StorageFacilityException($e->getMessage());
         }
     } else {
         throw new StorageFacilityException("Local file not found '" . $file->getLocalPath() . "'");
     }
     $file->setLocalPath($storagePath);
     $file->setUrl($this->generateUrl($params, $file->getId()));
     return $file;
 }
Пример #7
0
 /**
  * 
  * Construct a Storage instance placed inside the specified folder with the specified name,
  * of the specified type.
  * 
  * @param string $folder the folder name, as a string.
  * @param string $name the storage file name, as a string.
  * @param string $storage_t the storage file, actually the file extension.
  * @throws \Mbcraft\Piol\IOException if the parameters does not point to a valid storage location.
  * 
  * @internal
  */
 protected function __construct($folder, $name, $storage_t)
 {
     /*
      if (!preg_match(self::VALID_FOLDER_AND_STORAGE_NAME_PATTERN,$folder))
      throw new IOException("Nome del folder non valido!");
     
      if (!preg_match(self::VALID_FOLDER_AND_STORAGE_NAME_PATTERN,$name))
      throw new IOException("Nome del file non valido!");
     */
     $this->folder = $folder;
     $this->name = $name;
     $storage_dir = StorageFactory::getProtectedStorage();
     $this->storage_type = $storage_t;
     $p = $storage_dir->getPath() . $folder . DS;
     $this->storage_dir = new Dir($p);
     if (!FileSystemUtils::isValidFilename($name . "." . $storage_t)) {
         throw new IOException("The specified string is not a valid filename.");
     }
     $p = $storage_dir->getPath() . $folder . DS . $name . DOT . $storage_t;
     $this->storage_file = new File($p);
 }
Пример #8
0
 function execute()
 {
     $file_or_folder = $this->file_or_folder;
     $force = $this->force;
     if (self::$dummy_mode) {
         echo "Removing : " . $file_or_folder . "<br />";
         return;
     }
     $root_dir_path = self::$root_dir->getPath();
     //se è una cartella elimino solo i file che sono anche nel modulo
     if (FileSystemUtils::isDir($this->module_dir->getPath() . $file_or_folder)) {
         $source_dir = new Dir($this->module_dir->getPath() . $file_or_folder);
         $target_dir = new Dir($root_dir_path . $file_or_folder);
         if (!$target_dir->exists()) {
             return;
         }
         $toremove_files = $source_dir->listFiles();
         foreach ($toremove_files as $elem) {
             if ($elem->isDir()) {
                 $this->remove($file_or_folder . $elem->getName() . DS);
             } else {
                 $this->remove($file_or_folder . $elem->getFilename());
             }
         }
         if ($target_dir->isEmpty()) {
             $target_dir->delete(false);
         }
     } else {
         $source_file = new File($this->module_dir->getPath() . $file_or_folder);
         $target_file = new File($root_dir_path . $file_or_folder);
         if (!$force && !$source_file->exists()) {
             return;
         }
         //se non esiste nel modulo non lo rimuovo
         $target_file->delete();
     }
 }
Пример #9
0
 /**
  *
  * Copies this file to the target folder.
  *
  * @param \Mbcraft\Piol\Dir|string $target_dir The target dir or string path to copy this file into.
  * @param string $new_name An optional new name for the copied file.
  * @return boolean true if this operation was successfull, false otherwise.
  *
  * @api
  */
 public function copy($target_dir, $new_name = null)
 {
     $t_dir = Dir::asDir($target_dir);
     if ($new_name == null) {
         $n_name = $this->getFullName();
     } else {
         FileSystemUtils::checkValidFilename($new_name);
         $n_name = $new_name;
     }
     return copy($this->__full_path, $t_dir->__full_path . $n_name);
 }
 protected function deriveMetaDatatype(ValidationExpression $ve)
 {
     $v = $ve->getValidationArray();
     $datatype = $v['datatype'];
     switch ($datatype) {
         case 'flag':
             return 'flag';
         case 'boolean':
             return 'tiny';
         case 'date':
             if (isset($v['unix']) && !StringUtils::strToBool($v['unix'])) {
                 return 'datetime';
             }
             // If unix attribute is not specified, assume they want date (timestamp) for backward-compatibility
             return 'date';
         case 'int':
             $min = isset($v['min']) ? (int) $v['min'] : 0;
             $max = isset($v['max']) ? (int) $v['max'] : PHP_INT_MAX;
             if ($min < 0) {
                 if ($min >= -128 && $max <= 127) {
                     return 'tiny-signed';
                 } else {
                     if ($min >= -2147483648 && $max <= 2147483647) {
                         return 'int-signed';
                     }
                 }
                 return 'long-signed';
             }
             if ($max < 255) {
                 return 'tiny';
             } else {
                 if ($max <= 4294967295) {
                     return 'int';
                 }
             }
             return 'long';
         case 'float':
             return 'float';
         case 'slug':
         case 'slugwithslash':
         case 'email':
             $ve->setMax(255);
             // set max
             return 'varchar';
         case 'json':
             $ve->setMax(262144);
             //set max to 256K
             return 'mediumtext';
         case 'string':
         case 'html':
         case 'url':
             // NOTE: MySQL columns are bytes, string lengths are characters
             $max = 255;
             // default is 255
             if (isset($v['max'])) {
                 $max = (int) FileSystemUtils::iniValueInBytes($v['max']);
             }
             if ($max == 65536) {
                 $max = 65535;
             }
             if ($max > 262144) {
                 // max is 256K
                 $max = 262144;
             }
             $ve->setMax($max);
             // set max
             if ($max <= 255) {
                 // 255 or less is VARCHAR
                 return 'varchar';
             }
             if ($max <= 65535) {
                 // 64K or less is TEXT
                 return 'text';
             }
             if ($max <= 262144) {
                 // 256K or less is MEDIUMTEXT
                 return 'mediumtext';
             }
         case 'binary':
             $max = 262144;
             // default is 256K
             if (isset($v['max'])) {
                 $max = (int) FileSystemUtils::iniValueInBytes($v['max']);
             }
             if ($max == 65536) {
                 $max = 65535;
             }
             if ($max > 262144) {
                 // max is 256K
                 $max = 262144;
             }
             $ve->setMax($max);
             // set max
             if ($max <= 65535) {
                 // 64K or less, store as BLOB
                 return 'blob';
             }
             if ($max <= 262144) {
                 // 256K or less, store as MEDIUMBLOB
                 return 'mediumblob';
             }
     }
 }
Пример #11
0
 /**
  * Constructs a file cache store object.
  *
  * @param Logger      $Logger             our Logger
  * @param DateFactory $DateFactory        IoC Datefactory
  * @param string      $fileCacheDirectory The absolute path where our files will be stored without trailing '/'
  * @param string      $fileCachePrefixKey A prefix for the cache keys
  * @param boolean     $fileCacheEnabled   Flag to determine if caching is enabled
  * @param string      $fileCacheExtension The file extension to use for cache files.
  */
 public function __construct(LoggerInterface $Logger, DateFactory $DateFactory, $fileCacheDirectory, $fileCacheCachePrefixKey = '', $fileCacheEnabled = false, $fileCacheExtension = 'cfcache')
 {
     if ($fileCacheEnabled) {
         // Verify the directory exists and is writable
         if (!is_writable($fileCacheDirectory) && !@FileSystemUtils::recursiveMkdir($fileCacheDirectory)) {
             throw new CacheException("Directory '{$fileCacheDirectory}' does not exist or is not writable.");
         }
         // Remove any trailing DIRECTORY_SEPARATOR passed in
         // For example '/home/crowdfusion/filestore/' becomes '/home/crowdfusion/filestore'
         $fileCacheDirectory = rtrim($fileCacheDirectory, DIRECTORY_SEPARATOR);
         // Set our vars
         $this->cachePrefixKey = str_replace(' ', '', $fileCacheCachePrefixKey);
         $this->Logger = $Logger;
         $this->DateFactory = $DateFactory;
         $this->dir = $fileCacheDirectory;
         $this->enabled = $fileCacheEnabled;
         $this->fileExtension = $fileCacheExtension;
         $this->Logger->debug("Set FileStore options:\n" . "\tCachePrefix: {$fileCacheCachePrefixKey}\n" . "\tEnabled: TRUE");
     } else {
         $this->enabled = false;
     }
 }
 /**
  * Moves the file from the themes to the public app directory
  *
  * NOTE: the following code will overwrite files
  *
  * @param string $relpath  The relative path where the file lives
  * @param string $filename The file to move
  *
  * @return string the full path and filename of the moved file
  */
 public function putFile($relpath, $filename, $ts)
 {
     $basedir = $this->getBaseDeployDirectory() . $this->subject . '/';
     //move files from themes to public app directory
     $newfile = $basedir . $relpath;
     //        @FileSystemUtils::safeCopy($filename, $newfile);
     //        $ts = filemtime($filename);
     if (!file_exists($newfile) || $ts != filemtime($newfile)) {
         @FileSystemUtils::safeCopy($filename, $newfile);
         //@touch($newfile,$ts); //preserve original modified time
     }
     return new StorageFacilityFile('/' . ltrim($relpath, '/'), $newfile);
 }
 /**
  * Combines all the listed files into a single file at {@link $aggregatePath}
  *
  * @param string $md5           The md5 (stored in the aggregate)
  * @param array  $files         A list of files to store
  * @param string $aggregatePath The name of the file to write our aggregate to
  *
  * @return array An array with urls as the keys and data as values
  */
 protected function aggregateFiles($md5, array $files, $aggregatePath)
 {
     $this->Logger->debug('Rebuilding...');
     $file = array("md5" => $md5, $this->subject => array(), "files" => $files);
     $aggregateContents = "<?php\n\n\$contents = \n" . var_export($file, true) . "\n\n?><?php\n        \$" . $this->subject . " = array(\n        ";
     foreach ($files as $filename) {
         if (!file_exists($filename)) {
             continue;
         }
         $fileContents = file_get_contents($filename);
         $fileContents = preg_replace('/\\$' . $this->subject . '\\s*\\=\\s*array\\s*\\(/i', '', $fileContents);
         $fileContents = preg_replace('/\\<\\?php/i', '', $fileContents);
         $fileContents = preg_replace('/\\)\\;\\s*(\\?\\>)?/', '', $fileContents);
         $aggregateContents .= $fileContents;
         //            include $filename;
         //$subject = $this->subject;
         //            if (isset($$subject)) {
         //                foreach ($$subject as $url => $params)
         //                    $file[$this->subject][$url] = $params;
         //            }
     }
     $aggregateContents .= " ); ?>";
     //        if (empty(${$this->subject}))
     //            return array();
     FileSystemUtils::safeFilePutContents($aggregatePath, $aggregateContents);
     include $aggregatePath;
     return ${$this->subject};
 }
Пример #14
0
 /**
  * 
  * Saves the uploaded file into the specified folder optionally overriding the filename used during upload.
  * The temporary upload file is deleted.
  * 
  * @param \Mbcraft\Piol\Dir|string $dir The Dir instance or string path of the folder in which save the uploaded file.
  * @param string $new_name the optional name to use for the file (overrides upload filename).
  * @return \Mbcraft\Piol\File a File instance pointing to the saved file, or null if an error occurred.
  *
  * @throws \Mbcraft\Piol\IOException if something goes wrong (eg. the provided filename is not valid).
  * 
  * @api
  */
 public function moveTo($dir, $new_name = null)
 {
     $final_dir = Dir::asDir($dir);
     FileSystemUtils::checkValidFilename($new_name);
     if ($new_name == null) {
         $real_filename = $this->getFullName();
     } else {
         $real_filename = $new_name;
     }
     $final_file = $final_dir->newFile($real_filename);
     return $this->saveAs($final_file);
 }
 protected function _importPhotosFromJson($file)
 {
     try {
         $contents = file_get_contents($file);
         $json = JSONUtils::decode($contents);
         foreach ($json as $v) {
             echo "importing {$v->title}...";
             $url = $v->src;
             $parts = parse_url($url);
             $slug = SlugUtils::createSlug(basename($parts['path']));
             preg_match('/(\\.\\w*)$/', $parts['path'], $ext);
             $nodeRef = $this->NodeRefService->oneFromAspect('@images');
             $nodeRef = $this->NodeRefService->generateNodeRef($nodeRef, $slug);
             $node = $nodeRef->generateNode();
             if (!$this->NodeService->refExists($node->getNodeRef())) {
                 // go fetch file from url
                 $data = $this->HttpRequest->fetchURL($url);
                 // create a unique output file name
                 $sourceFile = FileSystemUtils::secureTmpname($this->workDir, 'urlfetch', !empty($ext[1]) ? strtolower($ext[1]) : null);
                 file_put_contents($sourceFile, $data);
                 $node->Title = rtrim($v->title);
                 $node->Status = "published";
                 $node->ActiveDate = $this->DateFactory->newStorageDate();
                 $node = $this->ImageService->storeMedia($sourceFile, $node, basename($parts['path']));
                 $this->NodeService->add($node);
                 echo "done\n";
             } else {
                 echo "exists\n";
             }
             unset($nodeRef);
             unset($node);
         }
     } catch (Exception $e) {
         echo "Exception: " . $e->getMessage() . "\n";
     }
 }
Пример #16
0
 /**
  * Marks up a string with paragraphs and automatically links any urls.
  *
  * This function marks up the output with paragraph tags and auto-links any URLs that are found.
  * The resulting output is suitable for display in any web-browser, but must have
  * paragraph and extra html tags removed before it's ready for editing.
  *
  * Content is XSS cleaned and stripped of all but a few tags (specified by implementation.)
  *
  * @param string $string      The HTML string to format
  * @param string $allowedTags (optional) A comma-separated list of allowed tags.
  *
  * @return string A nicely-formatted version of the input text, with automatic paragraphs and urls in place
  *
  * @see unAutoParagraph()
  */
 public function autoParagraph($string, $allowedTags = null, $linkUrls = true)
 {
     if (is_null($allowedTags)) {
         $allowedTags = $this->defaultAllowedTags;
     }
     if (is_null($this->purifier)) {
         require_once PATH_SYSTEM . '/vendors/HTMLPurifier.php';
         $this->purifier = HTMLPurifier::instance();
         FileSystemUtils::recursiveMkdir($this->vendorCacheDirectory . '/purifier/');
     }
     if ($this->injectors == null && $linkUrls) {
         $this->injectors = array(new CF_HTMLPurifier_Injector_Linkify());
     }
     $purifierConfig = array('Core.Encoding' => $this->charset, 'AutoFormat.AutoParagraph' => true, 'HTML.TidyLevel' => 'none', 'HTML.Allowed' => $allowedTags, 'Cache.SerializerPath' => $this->vendorCacheDirectory);
     if (!is_null($this->injectors)) {
         $purifierConfig['AutoFormat.Custom'] = $this->injectors;
     }
     $string = $this->purifier->purify($string, $purifierConfig);
     $string = str_replace("\n\n", '[DBLBR]', $string);
     $string = str_replace("\n", '<br/>', $string);
     $string = str_replace('[DBLBR]', "\n\n", $string);
     // trim links
     $string = preg_replace_callback("/\\<a\\s+href\\=\"(" . URLUtils::URL_MATCH . ")\"\\>\\1<\\/a\\>/Uix", array($this, 'trimCallback'), $string);
     // trim all words longer than 60 chars that aren't URLs, ignoring tags
     if (preg_match_all("/\\S60/", strip_tags(preg_replace('/(\\<(\\/?[^\\>]+)\\>)/', ' $1', $string)), $m)) {
         foreach ($m[0] as $n) {
             if (!preg_match("/" . URLUtils::URL_MATCH . "/", $n)) {
                 $string = str_replace($n, trim(substr($n, 0, 60 - 3), '.') . '...', $string);
             }
         }
     }
     return $string;
 }
 protected function executeExecImagick()
 {
     // get the width of the original image
     $retval = 1;
     $output = array();
     exec("{$this->imageIdentifyExecPath} -format %w " . escapeshellarg($this->sourceFile) . " 2>&1", $output, $retval);
     if ($retval > 0) {
         throw new ImageFilterException("Unable to read source file.");
     }
     $width = $output[0] - $this->padding * 2;
     // Step 1. Generate the photo credit
     $op = '';
     // store original values
     $targetFile = $this->targetFile;
     $this->targetFile = FileSystemUtils::secureTmpname($this->workDir, 'credit', '.' . $this->outputType);
     $op .= " -background '{$this->backgroundColor}'";
     if ($this->fontColor != null) {
         $op .= " -fill '{$this->fontColor}'";
     }
     if ($this->fontFamily != null) {
         $op .= " -font '{$this->fontFamily}'";
     }
     if ($this->fontStyle != null) {
         $op .= " -style '{$this->fontStyle}'";
     }
     if ($this->fontWeight != null) {
         $op .= " -weight '{$this->fontWeight}'";
     }
     $op .= " -pointsize {$this->fontSize}";
     // Force height to fontSize because IM < version 6.5.2-4 will ignore -pointsize to make the text fill the maximum width specified
     // I think this will limit all credit to 1 line of text
     $op .= " -size {$width}x{$this->fontSize}";
     $op .= " -gravity {$this->anchor}";
     $op .= " label:\"" . preg_replace('/"/', '\\"', $this->text) . "\"";
     $op .= " -bordercolor '{$this->backgroundColor}'";
     $op .= " -border {$this->padding}x{$this->padding}";
     $credit = ImagickExecFilterHelper::executeFilter($this, $op, true);
     // Step 2. Apply the photo credit
     // restore original values
     $this->targetFile = $targetFile;
     $op = '';
     if ($this->type == 'overlay') {
         $op .= " -gravity {$this->anchor}";
         $op .= " -draw 'image over 0,0 0,0 \"{$credit}\"'";
     } else {
         if ($this->type == 'add') {
             $op .= " -background '{$this->backgroundColor}'";
             $op .= " {$credit}";
             if (preg_match('/^North/i', $this->anchor)) {
                 $op .= " +swap";
             }
             if (preg_match('/^(North|South)$/i', $this->anchor)) {
                 $op .= " -gravity Center";
             } else {
                 if (preg_match('/East$/i', $this->anchor)) {
                     $op .= " -gravity East";
                 }
             }
             $op .= " -append";
         }
     }
     return ImagickExecFilterHelper::executeFilter($this, $op);
 }
Пример #18
0
<?php

require_once 'IConstants.inc';
require_once $ConstantsArray['dbServerUrl'] . "FormValidator//validator.php";
require $ConstantsArray['dbServerUrl'] . "DataStoreMgr//FolderDataStore.php";
require $ConstantsArray['dbServerUrl'] . "DataStoreMgr//LocationDataStore.php";
require $ConstantsArray['dbServerUrl'] . "Utils//FileSystemUtils.php";
require $ConstantsArray['dbServerUrl'] . "Utils//StringUtils.php";
$LDS = LocationDataStore::getInstance();
$msg = "";
if ($_POST["formAction"] == "delete") {
    $pathL = $_POST['locationPath'];
    $isLocationEmpty = FileSystemUtils::isDirEmpty($pathL);
    if ($isLocationEmpty) {
        $LDS->deleteBySeq($_POST['editSeq']);
        FileSystemUtils::delete_NestedDirectory($pathL);
        $msg = StringUtils::getMessage("Location", "Location deleted successfully", false);
    } else {
        $msg = StringUtils::getMessage("Delete Location", "-The Location that you are trying to delete is related to folders.", true);
    }
    //Delte folder from location
}
$locations = $LDS->FindAll();
?>
   
<!DOCTYPE html>
<html>
    <head>
    <?php 
include "_jsAdminInclude.php";
?>
Пример #19
0
 public function save()
 {
     if ($this->lockSystemChanges) {
         return;
     }
     if (!$this->changed) {
         return;
     }
     $xml = new SimpleXMLExtended('<system/>');
     $test = $xml->addChild('plugins');
     foreach ($this->plugins as $plugin) {
         $test->addXMLElement($this->SystemXMLConverter->pluginToXML($plugin));
     }
     $test = $xml->addChild('elements');
     foreach ($this->elements as $element) {
         $test->addXMLElement($this->SystemXMLConverter->elementToXML($element));
     }
     $test = $xml->addChild('aspects');
     foreach ($this->aspects as $aspect) {
         $test->addXMLElement($this->SystemXMLConverter->aspectToXML($aspect));
     }
     $test = $xml->addChild('cmsnavitems');
     foreach ($this->cmsNavItems as $navItem) {
         $test->addXMLElement($this->SystemXMLConverter->cmsNavItemToXML($navItem));
     }
     $newContents = $xml->asPrettyXML();
     $backup = $this->backupPath . '/system.' . $this->DateFactory->newStorageDate()->format('Y_m_d_His') . '.' . microtime(true) . '.xml';
     FileSystemUtils::safeCopy($this->systemXMLFile, $backup);
     FileSystemUtils::safeFilePutContents($this->systemXMLFile, $newContents);
     $this->ApplicationContext->clearContextFiles();
     $this->changed = false;
     $this->resetParsed();
 }
 /**
  * @dataProvider getBadExtensions
  *
  * @param string $extension
  */
 public function testGetMimetypeBadExtensions($extension)
 {
     $this->assertEquals('application/octet-stream', \FileSystemUtils::getMimetype($extension));
 }
Пример #21
0
 /**
  * 
  * Copies this directory and all its content to a new path.
  * 
  * @param \Mbcraft\Piol\Dir|string $path the path where to copy this folder and all its content.
  * @param string $new_name An aoptional new name for the copied folder.
  * 
  * @api
  */
 public function copy($path, $new_name = null)
 {
     $target_dir = Dir::asDir($path);
     if ($new_name == null) {
         $new_name = $this->getName();
     } else {
         FileSystemUtils::checkValidFilename($new_name);
     }
     $copy_dir = $target_dir->newSubdir($new_name);
     $results = $this->listElements(Dir::MODE_FILES_AND_FOLDERS);
     $all_elements = array_merge($results[0], $results[1]);
     foreach ($all_elements as $elem) {
         $elem->copy($copy_dir);
     }
 }
Пример #22
0
 /**
  * Processes an array (or single) of assets.
  *
  * @param array    $assets           Array of asset file names, or a single asset file name
  * @param string   $optionsKey       String representation of the options; used to create aggregated file name
  * @param string   $extension        File extension, 'js' or 'css'
  * @param callback $compressCallback Callback to execute to compress the contents of the asset.  If null, the
  *                                   contents won't be compressed.
  *
  * @return StorageFacilityFile Aggregated file stored in the aggregate storage facility (with url populated)
  */
 protected function processAsset($asset, $optionsKey, $extension)
 {
     $ts = $this->AssetService->getOriginTimestamp($asset);
     $prefix = '';
     $p = basename($asset);
     $prefix = rtrim($p, '.' . $extension) . '.';
     $cacheFileId = '/' . $this->cacheBasePath . '/' . $prefix . md5(serialize(array($asset, $optionsKey, $ts))) . ".v" . $this->DateFactory->newStorageDate($ts)->format(AssetAggregator::DATE_FORMAT) . "." . $extension;
     if (!$this->AssetService->fileExists($cacheFileId)) {
         $deployedfile = $this->AssetService->getOriginPath($asset);
         $contents = @file_get_contents($deployedfile);
         if ($contents === false) {
             throw new Exception("Reading contents of file '{$deployedfile}' for asset '{$asset}' failed (empty file contents will cause failure).");
         }
         // strip non-ASCII characters
         $contents = preg_replace('/[^(\\x20-\\x7F)\\x0A]*/', '', $contents);
         $tmpFile = $this->vendorCacheDirectory . '/assetCache' . $cacheFileId;
         if (!is_writable($this->vendorCacheDirectory)) {
             throw new Exception('Vendor cache directory is not writable: ' . $this->vendorCacheDirectory);
         }
         FileSystemUtils::safeFilePutContents($tmpFile, $contents);
         $this->AssetService->putFile($cacheFileId, $tmpFile, $ts);
     }
     $aggregateFile = $this->AssetService->resolveFile($cacheFileId);
     return $aggregateFile->getURL();
 }
Пример #23
0
 public function testAllInstalledProjectsInBaseDir()
 {
     $projects = FileSystemUtils::allInstalledProjectsInBaseDir(__DIR__ . '/fixtures/global');
     $this->assertEquals('org/example', implode(',', $projects));
 }
Пример #24
0
 public function maxUploadSize()
 {
     return FileSystemUtils::humanFileSize(FileSystemUtils::iniValueInBytes(ini_get('upload_max_filesize')));
 }
 public function processQuickAdd(NodeRef $nodeRef, Node &$newNode)
 {
     try {
         $workdir = $this->vendorCacheDirectory;
         $fileURL = (string) $this->Request->getParameter('FileURL');
         if (empty($fileURL)) {
             $fileURL = (string) $this->Request->getParameter('Url');
         }
         $dataURL = (string) $this->Request->getParameter('DataURL');
         if ($fileURL != null && trim($fileURL) !== '') {
             //process file from URL
             //                $data = $this->HttpRequest->fetchURL($fileURL);
             //
             //                if($data === FALSE)
             //                    throw new Exception("Could not get contents of image file at the specified URL.  Please try uploading the image from a local file.");
             //
             //                $basename = basename($fileURL);
             //
             //                if(($qpos = strpos($basename,'?')) !== false)
             //                    $basename = substr($basename,0,$qpos);
             //
             //                $uploadTempPath = rtrim($workdir, '/').'/uploads/'.$basename;
             //
             //                FileSystemUtils::safeFilePutContents($uploadTempPath, $data);
             $this->getMediaService()->storeMediaFromURL($fileURL, $newNode);
         } else {
             if ($dataURL != null && trim($dataURL) !== '') {
                 if (preg_match("/^data:(.*?);base64,(.*)\$/", $dataURL, $m)) {
                     $mimeType = $m[1];
                     $data = $m[2];
                     if (empty($data)) {
                         throw new Exception("Could not parse data from base64 encoded DataURL");
                     }
                     $mimeParts = explode('/', $mimeType);
                     $fname = mt_rand() . '.' . $mimeParts[1];
                     $newPath = rtrim($workdir, '/') . '/uploads/' . $fname;
                     FileSystemUtils::safeFilePutContents($newPath, base64_decode($data));
                     $this->getMediaService()->storeMedia($newPath, $newNode);
                 } else {
                     throw new Exception("Invalid base64 encoded DataURL format");
                 }
             } else {
                 foreach ($this->Request->getUploadedFiles() as $name => $upload) {
                     if (!$upload->isEmpty()) {
                         $dotPos = strrpos($upload->getName(), '.');
                         if ($dotPos === FALSE) {
                             throw new Exception("Uploaded file name missing extension!");
                         }
                         //$uploadBaseName = SlugUtils::createSlug($newNode->Title);
                         //$uploadExtension = strtolower(substr($upload->getName(), $dotPos+1));
                         //$uploadName = $uploadBaseName.'.'.$uploadExtension;
                         $uploadTempPath = $upload->getTemporaryName();
                         $newPath = rtrim($workdir, '/') . '/uploads/' . preg_replace('/[\\x80-\\xFF]/', '', $upload->getName());
                         //MOVE OR COPY UPLOADED FILE TO WORKING PATH
                         if (!$upload->transferTo($newPath)) {
                             throw new Exception('Unable to transfer upload to: ' . $newPath);
                         }
                         $this->getMediaService()->storeMedia($newPath, $newNode);
                         break;
                         //only process 1 uploaded file (for now)
                     } else {
                         throw new Exception("Unsuccessful upload: " . $upload->getHumanError());
                     }
                 }
             }
         }
     } catch (StorageFacilityException $sfe) {
         throw new Exception("An error occurred storing the file(s): " . $sfe->getMessage());
     } catch (ThumbnailsException $te) {
         throw new Exception("An error occurred generating the thumbnail(s): " . $te->getMessage());
     } catch (Exception $e) {
         throw new Exception("An error occurred while processing the file(s): " . $e->getMessage());
     }
 }
 /**
  * Checks and prepares the image for use.
  *
  * @param  $data  base64 encoded data string
  * @return string file path on disk
  * @throws ImageFilterException
  */
 protected function prepareImageData($data)
 {
     if (is_array($data)) {
         $uploadedFiles = $this->Request->getUploadedFiles();
         $sourceFileName = $data['filename'];
         $filename = null;
         foreach ($uploadedFiles as $uploadFile) {
             if ($uploadFile->getName() == $sourceFileName) {
                 $filename = $uploadFile->getTemporaryName();
                 break;
             }
         }
         if (empty($filename)) {
             throw new ImageFilterException("File '{$filename}' was not uploaded");
         }
         $file = file_get_contents($filename);
         unlink($filename);
     } else {
         if (preg_match('/^data:/', $data)) {
             $data = substr($data, strpos($data, ",") + 1);
             if (!($file = base64_decode($data, true))) {
                 throw new ImageFilterException('Data string is not a valid base64 encoded file.');
             }
         } else {
             throw new ImageFilterException('No file was provided.');
         }
     }
     // create a unique output file name
     $sourceFile = FileSystemUtils::secureTmpname($this->workDir, 'base64fetch');
     file_put_contents($sourceFile, $file);
     return $sourceFile;
 }
Пример #27
0
 protected function logLine($message)
 {
     FileSystemUtils::safeFilePutContents($this->logFile, '[' . date('Y-m-d H:i:s') . '] ' . $message . "\n", FILE_APPEND);
 }
Пример #28
0
<?php

/**
 * This file contains all the requires that loads all the library classes. You can require
 * this class and forget all other require and dependency stuff.
 * 
 */
namespace Mbcraft\Piol;

require_once "PiolObject.php";
require_once "FileSystemUtils.php";
FileSystemUtils::checkPiolRootPath();
require_once "IOException.php";
require_once "__FileSystemElement.php";
require_once "Utils/IniPropertiesUtils.php";
require_once "Utils/JavaXmlPropertiesUtils.php";
require_once "FileReader.php";
require_once "FileWriter.php";
require_once "File.php";
require_once "Dir.php";
require_once "Storage.php";
require_once "StorageDrivers/DataStorage.php";
require_once "StorageDrivers/PropertiesStorage.php";
require_once "StorageDrivers/XMLStorage.php";
require_once "Upload.php";
require_once "UploadUtils.php";
require_once "Cache/ICache.php";
require_once "Cache/FlatDirCache.php";
if (defined("ZipArchive")) {
    require_once "ZipUtils.php";
}
 protected function executeExecImagick()
 {
     // Step 1. Generate the watermark
     $op = '';
     // store original values
     $fileType = $this->outputType;
     $targetFile = $this->targetFile;
     $this->outputAlpha = true;
     if ($this->type == 'text') {
         $this->outputType = 'png';
         $this->targetFile = FileSystemUtils::secureTmpname($this->workDir, 'watermark', '.' . $this->outputType);
         $op .= " -background transparent";
         $op .= " -fill '{$this->fontColor}'";
         if (!empty($this->fontFamily)) {
             $op .= " -font '{$this->fontFamily}'";
         }
         if (!empty($this->fontStyle)) {
             $op .= " -style '{$this->fontStyle}'";
         }
         if (!empty($this->fontWeight)) {
             $op .= " -weight '{$this->fontWeight}'";
         }
         $op .= " -size {$this->width}x{$this->height}";
         if (!empty($this->fontSize)) {
             $op .= " -pointsize {$this->fontSize}";
         }
         $op .= " caption:\"" . preg_replace('/"/', '\\"', $this->text) . "\"";
         $watermark = ImagickExecFilterHelper::executeFilter($this, $op, true);
     } else {
         if ($this->type == 'image') {
             $watermark = $this->image;
         }
     }
     // Step 2. Apply the watermark
     // restore original values
     $this->outputType = $fileType;
     $this->targetFile = $targetFile;
     /** This only works with IM > 6.5.3-4 **/
     /*$op = "\"{$watermark}\"";
     
             $op .= " -compose dissolve";
     
             $op .= " -define compose:args={$this->opacity}";
     
             $op .= " -gravity {$this->anchor}";
     
             $op .= " -geometry {$this->offsetX}{$this->offsetY}";
     
             $op .= " -composite";
     
             $image = ImagickExecFilterHelper::executeFilter($this, $op);*/
     $inFile = escapeshellarg($this->sourceFile);
     $outFile = escapeshellarg($this->targetFile);
     $op = " -dissolve {$this->opacity}";
     $op .= " -gravity {$this->anchor}";
     $op .= " -geometry {$this->offsetX}{$this->offsetY}";
     $op .= " \"{$watermark}\"";
     $op .= " {$inFile}";
     if ($this->outputAlpha != null) {
         if ($this->outputAlpha == true) {
             $op .= " -alpha On";
         } else {
             $op .= " -alpha Off";
         }
     }
     $op .= " -quality {$this->outputQuality}";
     $cmdParams = "{$op} {$outFile}";
     $cmd = "{$this->imageCompositeExecPath} {$cmdParams} 2>&1";
     $retval = 1;
     $output = array();
     exec($cmd, $output, $retval);
     if ($retval > 0) {
         throw new ImageFilterException("Image filter process failed", $output);
     }
     @unlink($watermark);
     return $this->targetFile;
 }
 public function quickAdd()
 {
     try {
         $this->checkNonce();
         try {
             $mediaElementStr = (string) $this->Request->getRequiredParameter('ParentElement');
             $mediaElement = $this->ElementService->getBySlug($mediaElementStr);
             $workdir = $this->vendorCacheDirectory;
             $fileURL = (string) $this->Request->getParameter('FileURL');
             if ($fileURL != null && trim($fileURL) !== '') {
                 //process file from URL
                 $data = $this->HttpRequest->fetchURL($fileURL);
                 if ($data === FALSE) {
                     throw new Exception("Could not get contents of file at the specified URL.  Please try uploading the file from a local file.");
                 }
                 $basename = basename($fileURL);
                 if (($qpos = strpos($basename, '?')) !== false) {
                     $basename = substr($basename, 0, $qpos);
                 }
                 $uploadTempPath = rtrim($workdir, '/') . '/uploads/' . $basename;
                 FileSystemUtils::safeFilePutContents($uploadTempPath, $data);
                 $node = $this->FileService->createFileNode($mediaElement, null, $uploadTempPath);
             } else {
                 foreach ($this->Request->getUploadedFiles() as $name => $upload) {
                     if (!$upload->isEmpty()) {
                         $dotPos = strrpos($upload->getName(), '.');
                         if ($dotPos === FALSE) {
                             throw new Exception("Uploaded file name missing extension!");
                         }
                         //$uploadBaseName = SlugUtils::createSlug($newNode->Title);
                         //$uploadExtension = strtolower(substr($upload->getName(), $dotPos+1));
                         //$uploadName = $uploadBaseName.'.'.$uploadExtension;
                         $uploadTempPath = $upload->getTemporaryName();
                         $newPath = rtrim($workdir, '/') . '/uploads/' . $upload->getName();
                         //MOVE OR COPY UPLOADED FILE TO WORKING PATH
                         if (!$upload->transferTo($newPath)) {
                             throw new Exception('Unable to transfer upload to: ' . $newPath);
                         }
                         $node = $this->FileService->createFileNode($mediaElement, null, $newPath);
                         break;
                         //only process 1 uploaded file (for now)
                     } else {
                         throw new Exception("Unsuccessful upload: " . $upload->getHumanError());
                     }
                 }
             }
         } catch (StorageFacilityException $sfe) {
             throw new Exception("An error occurred storing the media file(s): " . $sfe->getMessage());
         } catch (ThumbnailsException $te) {
             throw new Exception("An error occurred generating the thumbnail(s): " . $te->getMessage());
         } catch (HttpRequestServerException $hrse) {
             throw new Exception("An error occurred while fetching the media file(s): " . $hrse->getCode());
         } catch (Exception $e) {
             throw new Exception("An error occurred while processing the media file(s): " . $e->getMessage());
         }
         // create node
         $this->getErrors()->throwOnError();
         $node = $this->RegulatedNodeService->getByNodeRef($node->getNodeRef(), new NodePartials());
         $this->bindToActionDatasource(array($node));
         return new View($this->successView());
     } catch (ValidationException $e) {
         $this->bindToActionDatasource(array());
         throw $e;
     } catch (Exception $e) {
         $this->bindToActionDatasource(array());
         $this->errors->addGlobalError($e->getCode(), $e->getMessage())->throwOnError();
     }
 }