Пример #1
0
 public function find($path)
 {
     try {
         $binaryFile = $this->ioService->loadBinaryFile($path);
         // Treat a MissingBinaryFile as a not loadable file.
         if ($binaryFile instanceof MissingBinaryFile) {
             throw new NotLoadableException("Source image not found in {$path}");
         }
         $mimeType = $this->ioService->getMimeType($path);
         return new Binary($this->ioService->getFileContents($binaryFile), $mimeType, $this->extensionGuesser->guess($mimeType));
     } catch (NotFoundException $e) {
         throw new NotLoadableException("Source image not found in {$path}", 0, $e);
     }
 }
Пример #2
0
 public function storeFieldData(VersionInfo $versionInfo, Field $field, array $context)
 {
     $contentMetaData = array('fieldId' => $field->id, 'versionNo' => $versionInfo->versionNo, 'languageCode' => $field->languageCode);
     // new image
     if (isset($field->value->externalData)) {
         $targetPath = sprintf('%s/%s', $this->pathGenerator->getStoragePathForField($field->id, $versionInfo->versionNo, $field->languageCode), $field->value->externalData['fileName']);
         if (isset($field->value->externalData['id'])) {
             $binaryFile = $this->IOService->loadBinaryFile($field->value->externalData['id']);
         } else {
             if ($this->IOService->exists($targetPath)) {
                 $binaryFile = $this->IOService->loadBinaryFile($targetPath);
             } else {
                 if (isset($field->value->externalData['inputUri'])) {
                     $localFilePath = $field->value->externalData['inputUri'];
                     unset($field->value->externalData['inputUri']);
                     $binaryFileCreateStruct = $this->IOService->newBinaryCreateStructFromLocalFile($localFilePath);
                     $binaryFileCreateStruct->id = $targetPath;
                     $binaryFile = $this->IOService->createBinaryFile($binaryFileCreateStruct);
                     $imageSize = getimagesize($localFilePath);
                     $field->value->externalData['width'] = $imageSize[0];
                     $field->value->externalData['height'] = $imageSize[1];
                 } else {
                     throw new InvalidArgumentException("inputUri", "No source image could be obtained from the given external data");
                 }
             }
         }
         $field->value->externalData['imageId'] = $versionInfo->contentInfo->id . '-' . $field->id;
         $field->value->externalData['uri'] = $binaryFile->uri;
         $field->value->externalData['id'] = $binaryFile->id;
         $field->value->externalData['mime'] = $this->IOService->getMimeType($binaryFile->id);
         $field->value->data = array_merge($field->value->externalData, $contentMetaData);
         $field->value->externalData = null;
     } else {
         if ($field->value->data === null) {
             // Store empty value only with content meta data
             $field->value->data = $contentMetaData;
             return false;
         }
         $this->IOService->loadBinaryFile($field->value->data['id']);
         $field->value->data = array_merge($field->value->data, $contentMetaData);
         $field->value->externalData = null;
     }
     $this->getGateway($context)->storeImageReference($field->value->data['uri'], $field->id);
     // Data has been updated and needs to be stored!
     return true;
 }
Пример #3
0
 public function getMimeType($binaryFileId)
 {
     // If the id is an internal (absolute) path to a draft image, use the draft service to get external path & load
     if ($this->isDraftImagePath($binaryFileId)) {
         return $this->draftIOService->getMimeType($this->draftIOService->getExternalPath($binaryFileId));
     }
     // If the id is an internal path (absolute) to a published image, replace with the internal path
     if ($this->isPublishedImagePath($binaryFileId)) {
         $binaryFileId = $this->publishedIOService->getExternalPath($binaryFileId);
     }
     return $this->publishedIOService->getMimeType($binaryFileId);
 }
 /**
  * {@inheritdoc}
  */
 public function prepare(Request $request)
 {
     $this->headers->set('Content-Length', $this->file->size);
     $this->headers->set('Accept-Ranges', 'bytes');
     $this->headers->set('Content-Transfer-Encoding', 'binary');
     if (!$this->headers->has('Content-Type')) {
         $this->headers->set('Content-Type', $this->ioService->getMimeType($this->file->id) ?: 'application/octet-stream');
     }
     if ('HTTP/1.0' != $request->server->get('SERVER_PROTOCOL')) {
         $this->setProtocolVersion('1.1');
     }
     $this->ensureIEOverSSLCompatibility($request);
     $this->offset = 0;
     $this->maxlen = -1;
     if ($request->headers->has('Range')) {
         // Process the range headers.
         if (!$request->headers->has('If-Range') || $this->getEtag() == $request->headers->get('If-Range')) {
             $range = $request->headers->get('Range');
             $fileSize = $this->file->size;
             list($start, $end) = explode('-', substr($range, 6), 2) + array(0);
             $end = '' === $end ? $fileSize - 1 : (int) $end;
             if ('' === $start) {
                 $start = $fileSize - $end;
                 $end = $fileSize - 1;
             } else {
                 $start = (int) $start;
             }
             if ($start <= $end) {
                 if ($start < 0 || $end > $fileSize - 1) {
                     $this->setStatusCode(416);
                     // HTTP_REQUESTED_RANGE_NOT_SATISFIABLE
                 } else {
                     if ($start !== 0 || $end !== $fileSize - 1) {
                         $this->maxlen = $end < $fileSize ? $end - $start + 1 : -1;
                         $this->offset = $start;
                         $this->setStatusCode(206);
                         // HTTP_PARTIAL_CONTENT
                         $this->headers->set('Content-Range', sprintf('bytes %s-%s/%s', $start, $end, $fileSize));
                         $this->headers->set('Content-Length', $end - $start + 1);
                     }
                 }
             }
         }
     }
     return $this;
 }
    /**
     * @see \eZ\Publish\SPI\FieldType\FieldStorage
     */
    public function storeFieldData( VersionInfo $versionInfo, Field $field, array $context )
    {
        $contentMetaData = array(
            'fieldId' => $field->id,
            'versionNo' => $versionInfo->versionNo,
            'languageCode' => $field->languageCode,
        );

        // new image
        if ( isset( $field->value->externalData ) )
        {
            $targetPath = sprintf(
                '%s/%s',
                $this->pathGenerator->getStoragePathForField(
                    $field->id,
                    $versionInfo->versionNo,
                    $field->languageCode
                ),
                $field->value->externalData['fileName']
            );

            if ( $this->IOService->exists( $targetPath ) )
            {
                $binaryFile = $this->IOService->loadBinaryFile( $targetPath );
            }
            else
            {
                if ( isset( $field->value->externalData['inputUri'] ) )
                {
                    $localFilePath = $field->value->externalData['inputUri'];
                    unset( $field->value->externalData['inputUri'] );
                }
                else
                {
                    $this->deprecationWarner->log(
                        "Using the Image\\Value::\$id property to create images is deprecated. Use 'inputUri'"
                    );
                    $localFilePath = $field->value->externalData['id'];
                }
                $binaryFileCreateStruct = $this->IOService->newBinaryCreateStructFromLocalFile( $localFilePath );
                $binaryFileCreateStruct->id = $targetPath;
                $binaryFile = $this->IOService->createBinaryFile( $binaryFileCreateStruct );

                $imageSize = getimagesize( $localFilePath );
                $field->value->externalData['width'] = $imageSize[0];
                $field->value->externalData['height'] = $imageSize[1];
            }
            $field->value->externalData['imageId'] = $versionInfo->contentInfo->id . '-' . $field->id;
            $field->value->externalData['uri'] = $binaryFile->uri;
            $field->value->externalData['id'] = $binaryFile->id;
            $field->value->externalData['mime'] = $this->IOService->getMimeType( $binaryFile->id );

            $field->value->data = array_merge(
                $field->value->externalData,
                $contentMetaData
            );

            $field->value->externalData = null;
        }
        // existing image from another version
        else
        {
            if ( $field->value->data === null )
            {
                // Store empty value only with content meta data
                $field->value->data = $contentMetaData;
                return false;
            }

            $this->IOService->loadBinaryFile( $field->value->data['id'] );

            $field->value->data = array_merge(
                $field->value->data,
                $contentMetaData
            );
            $field->value->externalData = null;
        }

        $this->getGateway( $context )->storeImageReference( $field->value->data['uri'], $field->id );

        // Data has been updated and needs to be stored!
        return true;
    }