class.ilAssOrderingFormValuesObjectsConverter.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */

require_once 'Services/Form/interfaces/interface.ilFormValuesManipulator.php';

class ilAssOrderingFormValuesObjectsConverter implements ilFormValuesManipulator
{
    const INDENTATIONS_POSTVAR_SUFFIX = '_ordering';
    const INDENTATIONS_POSTVAR_SUFFIX_JS = '__default';
    
    const CONTEXT_MAINTAIN_ELEMENT_TEXT = 'maintainItemText';
    const CONTEXT_MAINTAIN_ELEMENT_IMAGE = 'maintainItemImage';
    const CONTEXT_MAINTAIN_HIERARCHY = 'maintainHierarchy';
    
    protected $context = null;
    
    protected $postVar = null;
    
    protected $imageRemovalCommand = null;
    
    protected $imageUrlPath;
    
    protected $imageFsPath;
    
    protected $thumbnailPrefix;
    
    public function getContext()
    {
        return $this->context;
    }
    
    public function setContext($context)
    {
        $this->context = $context;
    }
    
    public function getPostVar()
    {
        return $this->postVar;
    }
    
    public function setPostVar($postVar)
    {
        $this->postVar = $postVar;
    }
    
    public function getImageRemovalCommand()
    {
        return $this->imageRemovalCommand;
    }
    
    public function setImageRemovalCommand($imageRemovalCommand)
    {
        $this->imageRemovalCommand = $imageRemovalCommand;
    }
    
    public function getImageUrlPath()
    {
        return $this->imageUrlPath;
    }
    
    public function setImageUrlPath($imageUrlPath)
    {
        $this->imageUrlPath = $imageUrlPath;
    }
    
    public function getImageFsPath()
    {
        return $this->imageFsPath;
    }
    
    public function setImageFsPath($imageFsPath)
    {
        $this->imageFsPath = $imageFsPath;
    }
    
    public function getThumbnailPrefix()
    {
        return $this->thumbnailPrefix;
    }
    
    public function setThumbnailPrefix($thumbnailPrefix)
    {
        $this->thumbnailPrefix = $thumbnailPrefix;
    }
    
    public function getIndentationsPostVar()
    {
        $postVar = $this->getPostVar();
        $postVar .= self::INDENTATIONS_POSTVAR_SUFFIX;
        $postVar .= self::INDENTATIONS_POSTVAR_SUFFIX_JS;
        
        return $postVar;
    }
    
    protected function needsConvertToValues($elementsOrValues)
    {
        if (!count($elementsOrValues)) {
            return false;
        }
        
        return (current($elementsOrValues) instanceof ilAssOrderingElement);
    }
    
    public function manipulateFormInputValues($elementsOrValues)
    {
        if ($this->needsConvertToValues($elementsOrValues)) {
            $elementsOrValues = $this->collectValuesFromElements($elementsOrValues);
        }
        
        return $elementsOrValues;
    }
    
    protected function collectValuesFromElements(array $elements)
    {
        $values = array();
        
        foreach ($elements as $identifier => $orderingElement) {
            switch ($this->getContext()) {
                case self::CONTEXT_MAINTAIN_ELEMENT_TEXT:
                    
                    $values[$identifier] = $this->getTextContentValueFromObject($orderingElement);
                    break;
                
                case self::CONTEXT_MAINTAIN_ELEMENT_IMAGE:
                    
                    $values[$identifier] = $this->getImageContentValueFromObject($orderingElement);
                    break;
                
                case self::CONTEXT_MAINTAIN_HIERARCHY:
                    
                    $values[$identifier] = $this->getStructValueFromObject($orderingElement);
                    break;
                
                default:
                    throw new ilFormException('unsupported context: ' . $this->getContext());
            }
        }
        
        return $values;
    }
    
    protected function getTextContentValueFromObject(ilAssOrderingElement $element)
    {
        return $element->getContent();
    }
    
    protected function getImageContentValueFromObject(ilAssOrderingElement $element)
    {
        $element->setImagePathWeb($this->getImageUrlPath());
        $element->setImagePathFs($this->getImageFsPath());
        $element->setImageThumbnailPrefix($this->getThumbnailPrefix());
        
        return array(
            'title' => $element->getContent(),
            'src' => $element->getPresentationImageUrl()
        );
    }
    
    protected function getStructValueFromObject(ilAssOrderingElement $element)
    {
        return array(
            'answer_id' => $element->getId(),
            'random_id' => $element->getRandomIdentifier(),
            'content' => (string) $element->getContent(),
            'ordering_position' => $element->getPosition(),
            'ordering_indentation' => $element->getIndentation()
        );
    }
    
    protected function needsConvertToElements($valuesOrElements)
    {
        if (!count($valuesOrElements)) {
            return false;
        }
        
        return !(current($valuesOrElements) instanceof ilAssOrderingElement);
    }
    
    public function manipulateFormSubmitValues($valuesOrElements)
    {
        if ($this->needsConvertToElements($valuesOrElements)) {
            $valuesOrElements = $this->constructElementsFromValues($valuesOrElements);
        }
        
        return $valuesOrElements;
    }
    
    public function constructElementsFromValues(array $values)
    {
        $elements = array();
        
        $position = 0;
        
        foreach ($values as $identifier => $value) {
            $element = new ilAssOrderingElement();
            $element->setRandomIdentifier($identifier);
            
            $element->setPosition($position++);
            
            if ($this->getContext() == self::CONTEXT_MAINTAIN_HIERARCHY) {
                $element->setIndentation($value);
            } else {
                $element->setContent($value);
            }
            
            if ($this->getContext() == self::CONTEXT_MAINTAIN_ELEMENT_IMAGE) {
                $element->setUploadImageName($this->fetchSubmittedImageFilename($identifier));
                $element->setUploadImageFile($this->fetchSubmittedUploadFilename($identifier));
                
                $element->setImageRemovalRequest($this->wasImageRemovalRequested($identifier));
            }
            
            $elements[$identifier] = $element;
        }
        
        return $elements;
    }
    
    protected function fetchSubmittedImageFilename($identifier)
    {
        $fileUpload = $this->fetchElementFileUpload($identifier);
        return $this->fetchSubmittedFileUploadProperty($fileUpload, 'name');
    }
    
    protected function fetchSubmittedUploadFilename($identifier)
    {
        $fileUpload = $this->fetchElementFileUpload($identifier);
        return $this->fetchSubmittedFileUploadProperty($fileUpload, 'tmp_name');
    }
    
    protected function fetchSubmittedFileUploadProperty($fileUpload, $property)
    {
        if (!isset($fileUpload[$property]) || !strlen($fileUpload[$property])) {
            return null;
        }
        
        return $fileUpload[$property];
    }
    
    protected function fetchElementFileUpload($identifier)
    {
        $uploadFiles = $this->fetchSubmittedUploadFiles();
        
        if (!isset($uploadFiles[$identifier])) {
            return array();
        }
        
        return $uploadFiles[$identifier];
    }
    
    protected function fetchSubmittedUploadFiles()
    {
        $submittedUploadFiles = $this->getFileSubmitDataRestructuredByIdentifiers();
        //$submittedUploadFiles = $this->getFileSubmitsHavingActualUpload($submittedUploadFiles);
        return $submittedUploadFiles;
    }
    
    protected function getFileSubmitsHavingActualUpload($submittedUploadFiles)
    {
        foreach ($submittedUploadFiles as $identifier => $uploadProperties) {
            if (!isset($uploadProperties['tmp_name'])) {
                unset($submittedUploadFiles[$identifier]);
                continue;
            }
            
            if (!strlen($uploadProperties['tmp_name'])) {
                unset($submittedUploadFiles[$identifier]);
                continue;
            }
            
            if (!is_uploaded_file($uploadProperties['tmp_name'])) {
                unset($submittedUploadFiles[$identifier]);
                continue;
            }
        }
        
        return $submittedUploadFiles;
    }
    
    protected function getFileSubmitDataRestructuredByIdentifiers()
    {
        $submittedUploadFiles = array();
        
        foreach ($this->getFileSubmitData() as $uploadProperty => $valueElement) {
            foreach ($valueElement as $elementIdentifier => $uploadValue) {
                if (!isset($submittedUploadFiles[$elementIdentifier])) {
                    $submittedUploadFiles[$elementIdentifier] = array();
                }
                
                $submittedUploadFiles[$elementIdentifier][$uploadProperty] = $uploadValue;
            }
        }
        
        return $submittedUploadFiles;
    }
    
    protected function getFileSubmitData()
    {
        if (!isset($_FILES[$this->getPostVar()])) {
            return array();
        }
        
        return $_FILES[$this->getPostVar()];
    }
    
    protected function wasImageRemovalRequested($identifier)
    {
        if (!$this->getImageRemovalCommand()) {
            return false;
        }
        
        if (!isset($_POST['cmd']) || !is_array($_POST['cmd'])) {
            return false;
        }
        
        $cmdArr = $_POST['cmd'];
        
        if (!isset($cmdArr[$this->getImageRemovalCommand()])) {
            return false;
        }
        
        $fieldArr = $cmdArr[$this->getImageRemovalCommand()];
            
        if (!isset($fieldArr[$this->getPostVar()])) {
            return false;
        }
        
        $identifierArr = $fieldArr[$this->getPostVar()];
    
        return key($identifierArr) == $identifier;
    }
}