MetadataManager::addEntityType() - Code Metrics - Inspection of "WIP: Fix metadata manager serialisation" - Algo-Web/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#100)

by Alex

created 2017-06-02 14:02 UTC

MetadataManager::addEntityType() B

↳ Parent: MetadataManager

Complexity

Conditions	5
Paths	8

Size

Total Lines	27
Code Lines	20

Duplication

Lines	5
Ratio	18.52 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
c	3
b	0
f	0
dl	5
loc	27
rs	8.439
cc	5
eloc	20
nc	8
nop	4

<?php

namespace AlgoWeb\ODataMetadata;

use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer\AssociationSetAnonymousType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer\AssociationSetAnonymousType\EndAnonymousType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer\EntitySetAnonymousType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationEndType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypePropertyType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TConstraintType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TDocumentationType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityPropertyType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TNavigationPropertyType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyRefType;
use AlgoWeb\ODataMetadata\MetadataV3\edm\TReferentialConstraintRoleElementType;
use AlgoWeb\ODataMetadata\MetadataV3\edmx\Edmx;
use Illuminate\Support\Str;
use JMS\Serializer\SerializerBuilder;

class MetadataManager
{
    private $V3Edmx = null;
    private $lastError = null;
    private $serializer = null;

    public function __construct($namespaceName = "Data", $containerName = "DefaultContainer")
    {
        $this->V3Edmx = new Edmx($namespaceName, $containerName);
        if (!$this->V3Edmx->isOK($msg)) {
            throw new \Exception($msg);
        }
        $this->initSerialiser();
        assert(null != $this->serializer, "Serializer must not be null at end of constructor");
    }

    public function getEdmx()
    {
        $msg = null;
        assert($this->V3Edmx->isOk($msg), $msg);
        return $this->V3Edmx;
    }

    public function getEdmxXML()
    {
        assert(null != $this->serializer, "Serializer must not be null when trying to get edmx xml");
        return $this->serializer->serialize($this->getEdmx(), "xml");
    }

    public function addEntityType($name, $accessType = "Public", $summary = null, $longDescription = null)
    {
        $NewEntity = new TEntityTypeType();
        $NewEntity->setName($name);
        if (null != $summary || null != $longDescription) {
            $documentation = $this->generateDocumentation($summary, $longDescription);
            $NewEntity->setDocumentation($documentation);
        }

        $entitySet = new EntitySetAnonymousType();
        $entitySet->setName(Str::plural($NewEntity->getName(), 2));
        $namespace = $this->V3Edmx->getDataServiceType()->getSchema()[0]->getNamespace();
        if (0 == strlen(trim($namespace))) {

            $entityTypeName = $NewEntity->getName();
        } else {
            $entityTypeName = $namespace . "." . $NewEntity->getName();
        }
        $entitySet->setEntityType($entityTypeName);
        $entitySet->setGetterAccess($accessType);

        $this->V3Edmx->getDataServiceType()->getSchema()[0]->addToEntityType($NewEntity);
        $this->V3Edmx->getDataServiceType()->getSchema()[0]->getEntityContainer()[0]->addToEntitySet($entitySet);
        if (!$this->V3Edmx->isok($this->lastError)) {
            return false;
        }
        return $NewEntity;
    }

    public function addComplexType($name, $accessType = "Public", $summary = null, $longDescription = null)
    {
        $NewEntity = new TComplexTypeType();
        $NewEntity->setName($name);
        $NewEntity->setTypeAccess($accessType);
        if (null != $summary || null != $longDescription) {

            $documentation = new TDocumentationType();
            $documentation->setSummary($summary);
            $documentation->setLongDescription($longDescription);
            $NewEntity->setDocumentation($documentation);
        }
        $this->V3Edmx->getDataServiceType()->getSchema()[0]->addToComplexType($NewEntity);

        return $NewEntity;
    }

    public function getSerialiser()
    {
        return $this->serializer;
    }

    public function addPropertyToComplexType(
        \AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType $complexType,
        $name,
        $type,
        $defaultValue = null,
        $nullable = false,
        $storeGeneratedPattern = null,
        $summary = null,
        $longDescription = null
    ) {
        $NewProperty = new TComplexTypePropertyType();
        $NewProperty->setName($name);
        $NewProperty->setType($type);
        $NewProperty->setStoreGeneratedPattern($storeGeneratedPattern);

        $NewProperty->setNullable($nullable);
        if (null != $summary || null != $longDescription) {
            $documentation = $this->generateDocumentation($summary, $longDescription);
            $NewProperty->addToDocumentation($documentation);
        }
        if (null != $defaultValue) {
            $NewProperty->setDefaultValue($defaultValue);
        }
        $complexType->addToProperty($NewProperty);
        return $NewProperty;
    }

    public function addPropertyToEntityType(
        $entityType,
        $name,
        $type,
        $defaultValue = null,
        $nullable = false,
        $isKey = false,
        $storeGeneratedPattern = null,
        $summary = null,
        $longDescription = null
    ) {
        $NewProperty = new TEntityPropertyType();
        $NewProperty->setName($name);
        $NewProperty->setType($type);
        $NewProperty->setStoreGeneratedPattern($storeGeneratedPattern);
        $NewProperty->setNullable($nullable);
        if (null != $summary || null != $longDescription) {

            $documentation = new TDocumentationType();
            $documentation->setSummary($summary);
            $documentation->setLongDescription($longDescription);
            $NewProperty->addToDocumentation($documentation);
        }
        if (null != $defaultValue) {
            $NewProperty->setDefaultValue($defaultValue);
        }
        $entityType->addToProperty($NewProperty);
        if ($isKey) {
            $Key = new TPropertyRefType();
            $Key->setName($name);
            $entityType->addToKey($Key);
        }
        if (!$this->V3Edmx->isok($this->lastError)) {
            return false;
        }
        return $NewProperty;
    }

    public function addNavigationPropertyToEntityType(
        TEntityTypeType $principalType,
        $principalMultiplicity,
        $principalProperty,
        TEntityTypeType $dependentType,
        $dependentMultiplicity,
        $dependentProperty = "",
        array $principalConstraintProperty = null,
        array $dependentConstraintProperty = null,
        $principalGetterAccess = "Public",
        $principalSetterAccess = "Public",
        $dependentGetterAccess = "Public",
        $dependentSetterAccess = "Public",
        $principalSummery = null,
        $principalLongDescription = null,
        $dependentSummery = null,
        $dependentLongDescription = null
    ) {
        $principalEntitySetName = Str::plural($principalType->getName(), 2);
        $dependentEntitySetName = Str::plural($dependentType->getName(), 2);
        $relationName = $principalType->getName() . "_" . $principalProperty . "_"
                        . $dependentType->getName() . "_" . $dependentProperty;
        $relationName = trim($relationName, "_");

        $namespace = $this->V3Edmx->getDataServiceType()->getSchema()[0]->getNamespace();
        if (0 == strlen(trim($namespace))) {
            $relationFQName = $relationName;
        } else {
            $relationFQName = $namespace . "." . $relationName;
        }

        $principalNavigationProperty = new TNavigationPropertyType();
        $principalNavigationProperty->setName($principalProperty);
        $principalNavigationProperty->setToRole(trim($dependentEntitySetName . "_" . $dependentProperty, "_"));
        $principalNavigationProperty->setFromRole($principalEntitySetName . "_" . $principalProperty);
        $principalNavigationProperty->setRelationship($relationFQName);
        $principalNavigationProperty->setGetterAccess($principalGetterAccess);
        $principalNavigationProperty->setSetterAccess($principalSetterAccess);
        if (null != $principalSummery || null != $principalLongDescription) {
            $principalDocumentation = new TDocumentationType();
            $principalDocumentation->setSummary($principalSummery);
            $principalDocumentation->setLongDescription($principalLongDescription);
            $principalNavigationProperty->setDocumentation($principalDocumentation);
        }
        $principalType->addToNavigationProperty($principalNavigationProperty);
        $dependentNavigationProperty = null;
        if (!empty($dependentProperty)) {
            $dependentNavigationProperty = new TNavigationPropertyType();
            $dependentNavigationProperty->setName($dependentProperty);
            $dependentNavigationProperty->setToRole($principalEntitySetName . "_" . $principalProperty);
            $dependentNavigationProperty->setFromRole($dependentEntitySetName . "_" . $dependentProperty);
            $dependentNavigationProperty->setRelationship($relationFQName);
            $dependentNavigationProperty->setGetterAccess($dependentGetterAccess);
            $dependentNavigationProperty->setSetterAccess($dependentSetterAccess);
            if (null != $dependentSummery || null != $dependentLongDescription) {
                $dependentDocumentation = new TDocumentationType();
                $dependentDocumentation->setSummary($dependentSummery);
                $dependentDocumentation->setLongDescription($dependentLongDescription);
                $dependentNavigationProperty->setDocumentation($dependentDocumentation);
            }
            $dependentType->addToNavigationProperty($dependentNavigationProperty);
        }

        $assocation = $this->createAssocationFromNavigationProperty(
            $principalType,
            $dependentType,
            $principalNavigationProperty,
            $dependentNavigationProperty,
            $principalMultiplicity,
            $dependentMultiplicity,
            $principalConstraintProperty,
            $dependentConstraintProperty
        );

        $this->V3Edmx->getDataServiceType()->getSchema()[0]->addToAssociation($assocation);

        $associationSet = $this->createAssocationSetForAssocation(
            $assocation,
            $principalEntitySetName,
            $dependentEntitySetName
        );

        $this->V3Edmx->getDataServiceType()->getSchema()[0]
            ->getEntityContainer()[0]->addToAssociationSet($associationSet);

        if (!$this->V3Edmx->isok($this->lastError)) {
            return false;
        }
        return [$principalNavigationProperty, $dependentNavigationProperty];
    }

    protected function createAssocationFromNavigationProperty(
        TEntityTypeType $principalType,
        TEntityTypeType $dependentType,
        TNavigationPropertyType $principalNavigationProperty,
        TNavigationPropertyType $dependentNavigationProperty = null,
        $principalMultiplicity,
        $dependentMultiplicity,
        array $principalConstraintProperty = null,
        array $dependentConstraintProperty = null
    ) {
        if (null != $dependentNavigationProperty) {
            if ($dependentNavigationProperty->getRelationship() != $principalNavigationProperty->getRelationship()) {
                $msg = "if you have both a dependent property and a principal property,"
                       ." they should both have the same relationship";
                throw new \Exception($msg);
            }
            if ($dependentNavigationProperty->getFromRole() != $principalNavigationProperty->getToRole() ||
                $dependentNavigationProperty->getToRole() != $principalNavigationProperty->getFromRole()
            ) {
                throw new \Exception("The from roles and two roles from matching properties should match");
            }
        }
        $namespace = $this->V3Edmx->getDataServiceType()->getSchema()[0]->getNamespace();

        if (0 == strlen(trim($namespace))) {
            $principalTypeFQName = $principalType->getName();
            $dependentTypeFQName = $dependentType->getName();
        } else {
            $principalTypeFQName = $namespace . "." . $principalType->getName();
            $dependentTypeFQName = $namespace . "." . $dependentType->getName();
        }
        $association = new TAssociationType();
        $relationship = $principalNavigationProperty->getRelationship();
        if (strpos($relationship, '.') !== false) {
            $relationship = substr($relationship, strpos($relationship, '.') + 1);
        }

        $association->setName($relationship);
        $principalEnd = new TAssociationEndType();
        $principalEnd->setType($principalTypeFQName);
        $principalEnd->setRole($principalNavigationProperty->getFromRole());
        $principalEnd->setMultiplicity($principalMultiplicity);
        $association->addToEnd($principalEnd);
        $dependentEnd = new TAssociationEndType();
        $dependentEnd->setType($dependentTypeFQName);
        $dependentEnd->setMultiplicity($dependentMultiplicity);
        $association->addToEnd($dependentEnd);

        if (null != $dependentNavigationProperty) {
            $dependentEnd->setRole($dependentNavigationProperty->getFromRole());
        } else {
            $dependentEnd->setRole($principalNavigationProperty->getToRole());
        }

        $principalReferralConstraint = null;
        $dependentReferralConstraint = null;

        if (null != $principalConstraintProperty && 0 < count($principalConstraintProperty)) {

            $principalReferralConstraint = new TReferentialConstraintRoleElementType();
            $principalReferralConstraint->setRole($principalNavigationProperty->getFromRole());
            foreach ($principalConstraintProperty as $propertyRef) {
                $TpropertyRef = new TPropertyRefType();
                $TpropertyRef->setName($propertyRef);
                $principalReferralConstraint->addToPropertyRef($TpropertyRef);
            }
        }
        if (null != $dependentConstraintProperty && 0 < count($dependentConstraintProperty)) {

            $dependentReferralConstraint = new TReferentialConstraintRoleElementType();
            $dependentReferralConstraint->setRole($dependentNavigationProperty->getFromRole());
function someFunction(A $objectMaybe = null)
{
    if ($objectMaybe instanceof A) {
        $objectMaybe->doSomething();
    }
}
            foreach ($dependentConstraintProperty as $propertyRef) {
                $TpropertyRef = new TPropertyRefType();
                $TpropertyRef->setName($propertyRef);
                $dependentReferralConstraint->addToPropertyRef($TpropertyRef);
            }
        }

        if (null != $dependentReferralConstraint || null != $principalReferralConstraint) {
            $constraint = new TConstraintType();
            $constraint->setPrincipal($principalReferralConstraint);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            $constraint->setDependent($dependentReferralConstraint);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            $association->setReferentialConstraint($constraint);
        }
        return $association;
    }

    protected function createAssocationSetForAssocation(
        TAssociationType $association,
        $principalEntitySetName,
        $dependentEntitySetName
    ) {
        $as = new AssociationSetAnonymousType();
        $name = $association->getName();
        $as->setName($name);
        $namespace = $this->V3Edmx->getDataServiceType()->getSchema()[0]->getNamespace();
        if (0 == strlen(trim($namespace))) {

            $associationSetName = $association->getName();
        } else {
            $associationSetName = $namespace . "." . $association->getName();
        }
        $as->setAssociation($associationSetName);
        $end1 = new EndAnonymousType();
        $end1->setRole($association->getEnd()[0]->getRole());
        $end1->setEntitySet($principalEntitySetName);
        $end2 = new EndAnonymousType();
        $end2->setRole($association->getEnd()[1]->getRole());
        $end2->setEntitySet($dependentEntitySetName);
        $as->addToEnd($end1);
        $as->addToEnd($end2);
        return $as;
    }

    public function getLastError()
    {
        return $this->lastError;
    }

    private function initSerialiser()
    {
        $ymlDir = __DIR__ . DIRECTORY_SEPARATOR . "MetadataV3" . DIRECTORY_SEPARATOR . "JMSmetadata";
        $this->serializer =
            SerializerBuilder::create()
                ->addMetadataDir($ymlDir)
                ->build();
    }

    public function __sleep()
    {
        $this->serializer = null;
        $result = array_keys(get_object_vars($this));
        return $result;
    }

    public function __wakeup()
    {
        $this->initSerialiser();
    }

    /**
     * @param $summary
     * @param $longDescription
     * @return TDocumentationType
     */
    private function generateDocumentation($summary, $longDescription)
    {
        $documentation = new TDocumentationType();
        $documentation->setSummary($summary);
        $documentation->setLongDescription($longDescription);
        return $documentation;
    }
}


1			<?php
2
3			namespace AlgoWeb\ODataMetadata;
4
5			use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer\AssociationSetAnonymousType;
6			use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer\AssociationSetAnonymousType\EndAnonymousType;
7			use AlgoWeb\ODataMetadata\MetadataV3\edm\EntityContainer\EntitySetAnonymousType;
8			use AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationEndType;
9			use AlgoWeb\ODataMetadata\MetadataV3\edm\TAssociationType;
10			use AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypePropertyType;
11			use AlgoWeb\ODataMetadata\MetadataV3\edm\TComplexTypeType;
12			use AlgoWeb\ODataMetadata\MetadataV3\edm\TConstraintType;
13			use AlgoWeb\ODataMetadata\MetadataV3\edm\TDocumentationType;
14			use AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityPropertyType;
15			use AlgoWeb\ODataMetadata\MetadataV3\edm\TEntityTypeType;
16			use AlgoWeb\ODataMetadata\MetadataV3\edm\TNavigationPropertyType;
17			use AlgoWeb\ODataMetadata\MetadataV3\edm\TPropertyRefType;
18			use AlgoWeb\ODataMetadata\MetadataV3\edm\TReferentialConstraintRoleElementType;
19			use AlgoWeb\ODataMetadata\MetadataV3\edmx\Edmx;
20			use Illuminate\Support\Str;
21			use JMS\Serializer\SerializerBuilder;
22
23			class MetadataManager
24			{
25			private $V3Edmx = null;
26			private $lastError = null;
27			private $serializer = null;
28
29			public function __construct($namespaceName = "Data", $containerName = "DefaultContainer")
30			{
31			$this->V3Edmx = new Edmx($namespaceName, $containerName);
32			if (!$this->V3Edmx->isOK($msg)) {
33			throw new \Exception($msg);
34			}
35			$this->initSerialiser();
36			assert(null != $this->serializer, "Serializer must not be null at end of constructor");
37			}
38
39			public function getEdmx()
40			{

Algo-Web / ODataMetadata

Pull Request — master (#100)

MetadataManager::addEntityType() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like