Concept::getProperties()

Complexity

Conditions	44
Paths	> 20000

Size

Total Lines	153
Code Lines	75

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	0	Features	0

<?php
    public function getProperties($allowedProperties = null)
    {
        $properties = array();
        $duplicates = array();
        $propertiesWithValues = array();

        $collectionData = $this->getCollectionMembersInUse();
        $inCollection = $collectionData['inCollection'];
        $membersArray = $collectionData['membersArray'];

        if (!empty($membersArray)) {
            $properties['skos:narrower'] = $membersArray;
        }

        foreach ($this->resource->propertyUris() as &$longUri) {

The expression $this->resource->propertyUris() cannot be used as a reference.

            // storing full URI without brackets in a separate variable
            $prop = $this->shortenOrKeep($longUri);
            // EasyRdf requires full URIs to be in angle brackets
            $sprop = ($prop == $longUri) ? "<$longUri>" : $prop;

            if ($allowedProperties !== null && !in_array($prop, $allowedProperties)) {
                continue;
            }

            if (!in_array($prop, $this->deleted) || ($this->isGroup() === false && $prop === 'skos:member')) {

$this->deleted of type mixed is incompatible with the type array expected by parameter $haystack of in_array().

                // retrieve property label and super properties from the current vocabulary first
                $propertyResource = new EasyRdf\Resource($prop, $this->graph);
                $proplabel = $propertyResource->label($this->getLang()) ? $propertyResource->label($this->getLang()) : $propertyResource->label();

                $prophelp = $propertyResource->getLiteral('rdfs:comment|skos:definition', $this->getLang());
                if ($prophelp === null) {
                    // try again without language restriction
                    $prophelp = $propertyResource->getLiteral('rdfs:comment|skos:definition');
                }

                // check if the property is one of the well-known properties for which we have a translation
                // if it is then we can skip the additional lookups in the default graph
                $propkey = (substr($prop, 0, 5) == 'dc11:') ?
                    str_replace('dc11:', 'dc:', $prop) : $prop;
                $is_well_known = ($this->model->getText($propkey) != $propkey);

                // if not found in current vocabulary, look up in the default graph to be able
                // to read an ontology loaded in a separate graph
                // note that this imply that the property has an rdf:type declared for the query to work
                if (!$is_well_known && !$proplabel) {
                    $envLangLabels = $this->model->getDefaultSparql()->queryLabel($longUri, $this->getLang());

                    $defaultPropLabel = $this->model->getDefaultSparql()->queryLabel($longUri, '');

                    if ($envLangLabels) {
                        $proplabel = $envLangLabels[$this->getLang()];
                    } else {
                        if ($defaultPropLabel) {
                            $proplabel = $defaultPropLabel[''];
                        }
                    }
                }

                // look for superproperties in the current graph
                $superprops = array();
                foreach ($this->graph->allResources($prop, 'rdfs:subPropertyOf') as $superProperty) {
                    $superprops[] = $superProperty->getUri();
                }

                // also look up superprops in the default graph if not found in current vocabulary
                if (!$is_well_known && (!$superprops || empty($superprops))) {
                    $superprops = $this->model->getDefaultSparql()->querySuperProperties($longUri);
                }

                // we're reading only one super property, even if there are multiple ones
                $superprop = ($superprops) ? $this->shortenOrKeep($superprops[0]) : null;
                $sort_by_notation = $this->vocab->getConfig()->getSortByNotation();
                $propobj = new ConceptProperty($this->model, $prop, $proplabel, $prophelp, $superprop, $sort_by_notation);

$this->model of type Model is incompatible with the type string expected by parameter $model of ConceptProperty::__construct().

It seems like $sort_by_notation can also be of type string; however, parameter $sort_by_notation of ConceptProperty::__construct() does only seem to accept boolean, maybe add an additional type check?

                if ($propobj->getLabel() !== null) {
                    // only display properties for which we have a label
                    $propertiesWithValues[$prop] = $propobj;
                }

                // searching for subproperties of literals too
                if ($superprops) {
                    foreach ($superprops as $superProperty) {
                        $duplicates[$this->shortenOrKeep($superProperty)] = $prop;
                    }
                }

                // Iterating through every literal and adding these to the data object.
                foreach ($this->resource->allLiterals($sprop) as $literalValue) {
                    $literal = new ConceptPropertyValueLiteral($this->model, $this->vocab, $this->resource, $literalValue, $prop);
                    // only add literals when they match the content/hit language or have no language defined OR when they are literals of a multilingual property
                    if (isset($propertiesWithValues[$prop]) && ($literal->getLang() === $this->clang || $literal->getLang() === null) || $this->vocab->getConfig()->hasMultiLingualProperty($prop)) {

Consider adding parentheses for clarity. Current Interpretation: (IssetNode && $literal->getLang() === $this->clang || $literal->getLang() === null) || $this->vocab->getConfig()->hasMultiLingualProperty($prop), Probably Intended Meaning: IssetNode && ($literal->getLang() === $this->clang || $literal->getLang() === null || $this->vocab->getConfig()->hasMultiLingualProperty($prop))

                        $propertiesWithValues[$prop]->addValue($literal);
                    }
                }

                // Iterating through every resource and adding these to the data object.
                foreach ($this->resource->allResources($sprop) as $resourceValue) {
                    // skipping narrower concepts which are already shown in a collection
                    if ($sprop === 'skos:narrower' && array_key_exists($resourceValue->getUri(), $inCollection)) {
                        continue;
                    }

                    // hiding rdf:type property if it's just skos:Concept
                    if ($sprop === 'rdf:type' && $resourceValue->shorten() === 'skos:Concept') {
                        continue;
                    }

                    // handled by getMappingProperties()
                    if (in_array($sprop, $this->MAPPING_PROPERTIES)) {
                        continue;
                    }

                    if (isset($propertiesWithValues[$prop])) {
                        // create a ConceptPropertyValue first, assuming the resource exists in current vocabulary
                        $value = new ConceptPropertyValue($this->model, $this->vocab, $resourceValue, $prop, $this->clang);
                        $propertiesWithValues[$prop]->addValue($value);
                    }

                }
            }
        }
        // adding narrowers part of a collection
        foreach ($properties as $prop => $values) {
            foreach ($values as $value) {
                $propertiesWithValues[$prop]->addValue($value);
            }
        }

        $groupPropObj = new ConceptProperty($this->model, 'skosmos:memberOf', null);
        foreach ($this->getGroupProperties() as $propVals) {
            foreach ($propVals as $propVal) {
                $groupPropObj->addValue($propVal);
            }
        }
        $propertiesWithValues['skosmos:memberOf'] = $groupPropObj;

        $arrayPropObj = new ConceptProperty($this->model, 'skosmos:memberOfArray', null);
        foreach ($this->getArrayProperties() as $propVals) {
            foreach ($propVals as $propVal) {
                $arrayPropObj->addValue($propVal);
            }
        }
        $propertiesWithValues['skosmos:memberOfArray'] = $arrayPropObj;

        foreach ($propertiesWithValues as $key => $prop) {
            if (sizeof($prop->getValues()) === 0) {
                unset($propertiesWithValues[$key]);
            }
        }

        $propertiesWithValues = $this->removeDuplicatePropertyValues($propertiesWithValues, $duplicates);
        // sorting the properties to the order preferred in the Skosmos concept page.
        return $this->arbitrarySort($propertiesWithValues);
    }