Content/Item.php

<?php
 
namespace ceLTIc\LTI\Content;
 
use ceLTIc\LTI\Util;
 
class Item
{
 
    const TYPE_LINK = 'link';
 
    const TYPE_LTI_LINK = 'ltiResourceLink';
 
    const TYPE_LTI_ASSIGNMENT = 'ltiAssignment';
 
    const TYPE_FILE = 'file';
 
    const TYPE_HTML = 'html';
 
    const TYPE_IMAGE = 'image';
 
    const LTI_LINK_MEDIA_TYPE = 'application/vnd.ims.lti.v1.ltilink';
 
    const LTI_ASSIGNMENT_MEDIA_TYPE = 'application/vnd.ims.lti.v1.ltiassignment';
 
    private $type = null;
 
    private $id = null;
 
    private $placements = array();
 
    private $url = null;
 
    private $mediaType = null;
 
    private $title = null;
 
    private $text = null;
 
    private $html = null;
 
    private $icon = null;
 
    private $thumbnail = null;
 
    private $hideOnCreate = null;
 
    function __construct($type, $placementAdvices = null, $id = null)
    {
        $this->type = $type;
        if (!empty($placementAdvices)) {
            if (!is_array($placementAdvices)) {
                $placementAdvices = array($placementAdvices);
            }
            foreach ($placementAdvices as $placementAdvice) {
                $this->placements[$placementAdvice->documentTarget] = $placementAdvice;
            }
        }
        $this->id = $id;
    }
 
    public function setUrl($url)
    {
        $this->url = $url;
    }
 
    public function setMediaType($mediaType)
    {
        $this->mediaType = $mediaType;
    }
 
    public function setTitle($title)
    {
        $this->title = $title;
    }
 
    public function setText($text)
    {
        $this->text = $text;
    }
 
    public function setHtml($html)
    {
        $this->html = $html;
    }
 
    public function addPlacementAdvice($placementAdvice)
    {
        if (!empty($placementAdvice)) {
            $this->placements[$placementAdvice->documentTarget] = $placementAdvice;
        }
    }
 
    public function setIcon($icon)
    {
        $this->icon = $icon;
    }
 
    public function setThumbnail($thumbnail)
    {
        $this->thumbnail = $thumbnail;
    }
 
    public function setHideOnCreate($hideOnCreate)
    {
        $this->hideOnCreate = $hideOnCreate;
    }
 
    public static function toJson($items, $ltiVersion = Util::LTI_VERSION1)
    {
        if (!is_array($items)) {
            $items = array($items);
        }
        if ($ltiVersion !== Util::LTI_VERSION1P3) {
            $obj = new \stdClass();
            $obj->{'@context'} = 'http://purl.imsglobal.org/ctx/lti/v1/ContentItem';
            $obj->{'@graph'} = array();
            foreach ($items as $item) {
                $obj->{'@graph'}[] = $item->toJsonldObject();
            }
        } else {
            $obj = array();
            foreach ($items as $item) {
                $obj[] = $item->toJsonObject();
            }
        }
 
        return json_encode($obj);
    }
 
    public static function fromJson($items)
    {
        $isJsonLd = isset($items->{'@graph'});
        if ($isJsonLd) {
            $items = $items->{'@graph'};
        }
        if (!is_array($items)) {
            $items = array($items);
        }
        $objs = array();
        foreach ($items as $item) {
            $obj = self::fromJsonItem($item);
            if (!empty($obj)) {
                $objs[] = $obj;
            }
        }
 
        return $objs;
    }
 
    protected function toJsonldObject()
    {
        $item = new \stdClass();
        if (!empty($this->id)) {
            $item->{'@id'} = $this->id;
        }
        if (!empty($this->type)) {
            if (($this->type === self::TYPE_LTI_LINK) || ($this->type === self::TYPE_LTI_ASSIGNMENT)) {
                $item->{'@type'} = 'LtiLinkItem';
            } elseif ($this->type === self::TYPE_FILE) {
                $item->{'@type'} = 'FileItem';
            } else {
                $item->{'@type'} = 'ContentItem';
            }
        } else {
            $item->{'@type'} = 'ContentItem';
        }
        if (!empty($this->title)) {
            $item->title = $this->title;
        }
        if (!empty($this->text)) {
            $item->text = $this->text;
        } elseif (!empty($this->html)) {
            $item->text = $this->html;
        }
        if (!empty($this->url)) {
            $item->url = $this->url;
        }
        if (!empty($this->mediaType)) {
            $item->mediaType = $this->mediaType;
        }
        if (!empty($this->placements)) {
            $placementAdvice = new \stdClass();
            $placementAdvices = array();
            foreach ($this->placements as $placement) {
                $obj = $placement->toJsonldObject();
                if (!empty($obj)) {
                    if (!empty($placement->documentTarget)) {
                        $placementAdvices[] = $placement->documentTarget;
                    }
                    $placementAdvice = (object) array_merge((array) $placementAdvice, (array) $obj);
                }
            }
            if (!empty($placementAdvice)) {
                $item->placementAdvice = $placementAdvice;
                if (!empty($placementAdvices)) {
                    $item->placementAdvice->presentationDocumentTarget = implode(',', $placementAdvices);
                }
            }
        }
        if (!empty($this->icon)) {
            $item->icon = $this->icon->toJsonldObject();
        }
        if (!empty($this->thumbnail)) {
            $item->thumbnail = $this->thumbnail->toJsonldObject();
        }
        if (!is_null($this->hideOnCreate)) {
            $item->hideOnCreate = $this->hideOnCreate;
        }
 
        return $item;
    }
 
    protected function toJsonObject()
    {
        $item = new \stdClass();
        switch ($this->type) {
            case 'LtiLinkItem':
                $item->type = self::TYPE_LTI_LINK;
                break;
            case 'FileItem':
                $item->type = self::TYPE_FILE;
                break;
            case 'ContentItem':
                if (empty($this->url)) {
                    $item->type = self::TYPE_HTML;
                } elseif (!empty($this->mediaType) && (strpos($this->mediaType, 'image') === 0)) {
                    $item->type = self::TYPE_IMAGE;
                } else {
                    $item->type = self::TYPE_LINK;
                }
                break;
            default:
                $item->type = $this->type;
                break;
        }
        if (!empty($this->title)) {
            $item->title = $this->title;
        }
        if (!empty($this->text)) {
            $item->text = Util::stripHtml($this->text);
        }
        if (!empty($this->html)) {
            $item->html = $this->html;
        }
        if (!empty($this->url)) {
            $item->url = $this->url;
        }
        foreach ($this->placements as $type => $placement) {
            switch ($type) {
                case Placement::TYPE_EMBED:
                case Placement::TYPE_IFRAME:
                case Placement::TYPE_WINDOW:
                case Placement::TYPE_FRAME:
                    $obj = $placement->toJsonObject();
                    break;
                default:
                    $obj = null;
                    break;
            }
            if (!empty($obj)) {
                $item->{$type} = $obj;
            }
        }
        if (!empty($this->icon)) {
            $item->icon = $this->icon->toJsonObject();
        }
        if (!empty($this->thumbnail)) {
            $item->thumbnail = $this->thumbnail->toJsonObject();
        }
        if (!is_null($this->hideOnCreate)) {
            $item->hideOnCreate = $this->hideOnCreate;
        }
 
        return $item;
    }
 
    public static function fromJsonItem($item)
    {
        $obj = null;
        $placement = null;
        if (isset($item->{'@type'})) {
            if (isset($item->presentationDocumentTarget)) {
                $placement = Placement::fromJsonObject($item, $item->presentationDocumentTarget);
            }
            switch ($item->{'@type'}) {
                case 'ContentItem':
                    $obj = new Item('ContentItem', $placement);
                    break;
                case 'LtiLinkItem':
                    $obj = new LtiLinkItem($placement);
                    break;
                case 'FileItem':
                    $obj = new FileItem($placement);
                    break;
            }
        } elseif (isset($item->type)) {
            $placements = array();
            $placement = Placement::fromJsonObject($item, 'embed');
            if (!empty($placement)) {
                $placements[] = $placement;
            }
            $placement = Placement::fromJsonObject($item, 'iframe');
            if (!empty($placement)) {
                $placements[] = $placement;
            }
            $placement = Placement::fromJsonObject($item, 'window');
            if (!empty($placement)) {
                $placements[] = $placement;
            }
            switch ($item->type) {
                case self::TYPE_LINK:
                case self::TYPE_HTML:
                case self::TYPE_IMAGE:
                    $obj = new Item($item->type, $placements);
                    break;
                case self::TYPE_LTI_LINK:
                    $obj = new LtiLinkItem($placements);
                    break;
                case self::TYPE_LTI_ASSIGNMENT:
                    $obj = new LtiAssignmentItem($placements);
                    break;
                case self::TYPE_FILE:
                    $obj = new FileItem($placements);
                    break;
            }
        }
        if (!empty($obj)) {
            $obj->fromJsonObject($item);
        }
 
        return $obj;
    }
 
    protected function fromJsonObject($item)
    {
        if (isset($item->{'@id'})) {
            $this->id = $item->{'@id'};
        }
        foreach (get_object_vars($item) as $name => $value) {
            switch ($name) {
                case 'title':
                case 'text':
                case 'html':
                case 'url':
                case 'mediaType':
                case 'hideOnCreate':
                    $this->{$name} = $item->{$name};
                    break;
                case 'placementAdvice':
                    $this->addPlacementAdvice(Placement::fromJsonObject($item));
                    break;
                case 'embed':
                case 'window':
                case 'iframe':
                    $this->addPlacementAdvice(Placement::fromJsonObject($item, $name));
                    break;
                case 'icon':
                case 'thumbnail':
                    $this->{$name} = Image::fromJsonObject($item->{$name});
                    break;
            }
        }
    }
 
}