ComponentEntry.php

Go to the documentation of this file.

<?php
 
/* Copyright (c) 2016 Timon Amstutz <timon.amstutz@ilub.unibe.ch> Extended GPL, see docs/LICENSE */
 
namespace ILIAS\UI\Implementation\Crawler\Entry;
 
class ComponentEntry extends AbstractEntryPart implements \JsonSerializable
{
    protected $id = "";
 
    protected $title = "";
 
    protected $is_abstract = false;
 
    protected $status_list_entry = array("Accepted","Proposed","To be revised");
 
    protected $status_list_implementation = array("Implemented","Partly implemented","To be implemented");
 
    protected $status_entry = "";
 
    protected $status_implementation = "";
 
    protected $description = null;
 
    protected $background = "";
 
    protected $context = [];
 
    protected $selector = "";
 
    protected $feature_wiki_references = array();
 
    protected $rules = null;
 
    protected $parent = false;
 
    protected $children = array();
 
    protected $less_variables = array();
 
    protected $path = "";
 
 
    protected $examples = null;
 
    protected $examples_path = "";
 
    public function __construct($entry_data)
    {
        parent::__construct();
        $this->assert()->isIndex('id', $entry_data);
        $this->setId($entry_data['id']);
        $this->assert()->isIndex('title', $entry_data);
        $this->setTitle($entry_data['title']);
        $this->assert()->isIndex('abstract', $entry_data);
        $this->setIsAbstract($entry_data['abstract']);
        $this->setStatusEntry("Proposed");
        $this->setStatusImplementation("Partly implemented");
        if (array_key_exists('description', $entry_data)) {
            $this->setDescription(new ComponentEntryDescription($entry_data['description']));
        }
        if (array_key_exists('rules', $entry_data)) {
            $this->setRules(new ComponentEntryRules($entry_data['rules']));
        }
 
        $this->assert()->isIndex('path', $entry_data);
        $this->setPath($entry_data['path']);
 
        if (array_key_exists('background', $entry_data)) {
            $this->setBackground($entry_data['background']);
        }
        if (array_key_exists('context', $entry_data)) {
            $this->setContext($entry_data['context']);
        }
        if (array_key_exists('featurewiki', $entry_data)) {
            $this->setFeatureWikiReferences($entry_data['featurewiki']);
        }
        if (array_key_exists('parent', $entry_data)) {
            $this->setParent($entry_data['parent']);
        }
        if (array_key_exists('children', $entry_data)) {
            $this->setChildren($entry_data['children']);
        }
 
        if (!$this->isAbstract()) {
            $this->readExamples();
        }
    }
 
    public function getId()
    {
        return $this->id;
    }
 
    public function setId($id)
    {
        $this->assert()->isString($id, false);
        $this->id = $id;
    }
 
    public function getTitle()
    {
        return $this->title;
    }
 
    public function setTitle($title)
    {
        $this->assert()->isString($title, false);
        $this->title = $title;
    }
 
    public function isAbstract()
    {
        return $this->is_abstract;
    }
 
    public function setIsAbstract($is_abstract)
    {
        $this->is_abstract = $is_abstract;
    }
 
    public function getStatusEntry()
    {
        return $this->status_entry;
    }
 
    public function setStatusEntry($status_entry)
    {
        $this->assert()->isString($status_entry);
        //$this->assert()->isIndex($status_entry,$this->status_list_entry);
 
        $this->status_entry = $status_entry;
    }
 
    public function getStatusImplementation()
    {
        return $this->status_implementation;
    }
 
    public function setStatusImplementation($status_implementation)
    {
        $this->assert()->isString($status_implementation);
        //$this->assert()->isIndex($status_implementation,$this->status_list_implementation);
 
        $this->status_implementation = $status_implementation;
    }
 
    public function getDescription()
    {
        return $this->description;
    }
 
    public function getDescriptionAsArray()
    {
        return $this->description->getDescription();
    }
 
    public function setDescription(ComponentEntryDescription $description)
    {
        $this->assert()->isTypeOf($description, ComponentEntryDescription::class);
        $this->description = $description;
    }
 
    public function getBackground()
    {
        return $this->background;
    }
 
    public function setBackground($background)
    {
        $this->assert()->isString($background);
        $this->background = $background;
    }
 
    public function getContext()
    {
        return $this->context;
    }
 
    public function setContext($context)
    {
        $this->assert()->isArray($context);
        $this->context = $context;
    }
 
 
    public function getFeatureWikiReferences()
    {
        return $this->feature_wiki_references;
    }
 
    public function setFeatureWikiReferences($feature_wiki_references)
    {
        $this->assert()->isArray($feature_wiki_references);
        $this->feature_wiki_references = $feature_wiki_references;
    }
 
    public function getRules()
    {
        return $this->rules;
    }
 
    public function getRulesAsArray()
    {
        if ($this->rules) {
            return $this->rules->getRules();
        } else {
            return [];
        }
    }
 
    public function setRules($rules)
    {
        $this->assert()->isTypeOf($rules, ComponentEntryRules::class);
        $this->rules = $rules;
    }
 
    public function getSelector()
    {
        return $this->selector;
    }
 
    public function setSelector($selector)
    {
        $this->assert()->isString($selector);
        $this->selector = $selector;
    }
 
    public function setLessVariables($less_variables)
    {
        $this->assert()->isArray($less_variables);
        $this->less_variables = $less_variables;
    }
 
    public function getLessVariables()
    {
        return $this->less_variables;
    }
 
    public function getPath()
    {
        return $this->path;
    }
 
    public function setPath($path)
    {
        $this->assert()->isString($path);
        $this->path = $path;
    }
 
    public function getParent()
    {
        return $this->parent;
    }
 
    public function setParent($parent)
    {
        $this->parent = $parent;
    }
 
    public function getChildren()
    {
        return $this->children;
    }
 
    public function setChildren($children)
    {
        $this->children = $children;
    }
 
    public function addChild($child)
    {
        $this->children[] = $child;
    }
 
    public function addChildren($children)
    {
        $this->setChildren(array_merge($this->children, $children));
    }
 
    public function getExamples()
    {
        return $this->examples;
    }
 
    protected function readExamples()
    {
        $this->examples = array();
        $case_insensitive_path = $this->getCaseInsensitiveExampleFolder();
        if (is_dir($case_insensitive_path)) {
            foreach (scandir($case_insensitive_path) as $file_name) {
                $example_path = $this->getExamplesPath() . "/" . $file_name;
                if (is_file($example_path) && pathinfo($example_path)["extension"] == "php") {
                    $example_name = str_replace(".php", "", $file_name);
                    $this->examples[$example_name] = $example_path;
                }
            }
        }
    }
 
    protected function getCaseInsensitiveExampleFolder() : string
    {
        $parent_folder = dirname($this->getExamplesPath());
 
        if (is_dir($parent_folder)) {
            foreach (scandir($parent_folder) as $folder_name) {
                if (strtolower($folder_name) == strtolower(basename($this->getExamplesPath()))) {
                    return $parent_folder . "/" . $folder_name;
                }
            }
        }
 
        return "";
    }
 
    public function getExamplesPath()
    {
        if (!$this->examples_path) {
            $path_componants = str_replace("Component", "examples", $this->getPath())
                    . "/" . str_replace(" ", "", $this->getTitle());
            $path_array = self::array_iunique(explode("/", $path_componants));
            $this->examples_path = implode("/", $path_array);
        }
        return $this->examples_path;
    }
 
 
    private static function array_iunique($array)
    {
        return array_intersect_key(
            $array,
            array_unique(array_map("StrToLower", $array))
        );
    }
 
 
    public function jsonSerialize()
    {
        $description = $this->getDescription();
        if ($description) {
            $description_serialized = $description->jsonSerialize();
        } else {
            $description_serialized = "";
        }
 
        $rules = $this->getRules();
        if ($rules) {
            $rules_serialized = $rules->jsonSerialize();
        } else {
            $rules_serialized = "";
        }
        return array(
            'id' => $this->getId(),
            'title' => $this->getTitle(),
            'abstract' => $this->isAbstract(),
            'status_entry' => $this->getStatusEntry(),
            'status_implementation' => $this->getStatusImplementation(),
            'description' => $description_serialized,
            'background' => $this->getBackground(),
            'context' => $this->getContext(),
            'selector' => $this->getSelector(),
            'feature_wiki_references' => $this->getFeatureWikiReferences(),
            'rules' => $rules_serialized,
            'parent' => $this->getParent(),
            'children' => $this->getChildren(),
            'less_variables' => $this->getLessVariables(),
            'path' => $this->getPath()
        );
    }
}