bedita / bedita

plugins/BEdita/Core/src/Model/Behavior/RelationsBehavior.php

<?php
/**
 * BEdita, API-first content management framework
 * Copyright 2017 ChannelWeb Srl, Chialab Srl
 *
 * This file is part of BEdita: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * See LICENSE.LGPL or <http://gnu.org/licenses/lgpl-3.0.html> for more details.
 */

namespace BEdita\Core\Model\Behavior;

use BEdita\Core\ORM\Association\RelatedTo;
use Cake\Datasource\Exception\RecordNotFoundException;
use Cake\ORM\Behavior;
use Cake\ORM\TableRegistry;
use League\JsonReference\Dereferencer;

The type League\JsonReference\Dereferencer was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * Relations behavior
 */
class RelationsBehavior extends Behavior
{

    /**
     * {@inheritDoc}
     */
    protected $_defaultConfig = [
        'implementedMethods' => [
            'setupRelations' => 'setupRelations',
            'getRelations' => 'getRelations',
        ],
    ];

    /**
     * {@inheritDoc}
     */
    public function initialize(array $config)
    {
        parent::initialize($config);

        $table = $this->getTable();
        if (!$table->hasBehavior('ObjectType')) {
            $table->addBehavior('BEdita/Core.ObjectType');
        }

        $this->setupRelations();
    }

    /**
     * Getter for object type.
     *
     * @param array $args Method arguments.
     * @return \BEdita\Core\Model\Entity\ObjectType
     */
    protected function objectType(...$args)
    {
        return $this->getTable()->behaviors()->call('objectType', $args);
    }

    /**
     * Creates a new RelatedTo association between this table and a target
     * table. A "belongs to many" association is a M-N relationship.
     *
     * Target table can be inferred by its name, which is provided in the
     * first argument, or you can either pass the class name to be instantiated or
     * an instance of it directly.
     *
     * The options array accept the same keys as {@see \Cake\ORM\Table::belongsToMany()}.
     *
     * This method will return the association object that was built.
     *
     * @param string $associated The alias for the target table. This is used to
     *      uniquely identify the association.
     * @param array $options List of options to configure the association definition.
     * @return \Cake\ORM\Association
     */
    protected function relatedTo($associated, array $options = [])
    {
        $options += ['sourceTable' => $this->getTable()];
        $association = new RelatedTo($associated, $options);

        return $this->getTable()->associations()->add($association->getName(), $association);
    }

    /**
     * Set up relations for the current table.
     *
     * @param string|int|null $objectType Object type name or ID.
     * @return void
     */
    public function setupRelations($objectType = null)
    {
        if ($objectType === null) {
            $objectType = $this->getTable()->getAlias();
        }

        try {
            $objectType = $this->objectType($objectType);
        } catch (RecordNotFoundException $e) {
            return;
        }

        // Add relations to the left side.
        foreach ($objectType->getRelations('left') as $relation) {
            if ($this->getTable()->association($relation->alias) !== null) {
                continue;
            }

            $className = 'BEdita/Core.Objects';
            if (count($relation->right_object_types) === 1) {
                $className = $relation->right_object_types[0]->table;
            }

            $through = TableRegistry::get(
                $relation->alias . 'ObjectRelations',
                ['className' => 'ObjectRelations']
            );
            $through->getValidator()->setProvider(
                'jsonSchema',
                Dereferencer::draft4()->dereference(json_decode(json_encode($relation->params)))
            );

            $this->relatedTo($relation->alias, [
                'className' => $className,
                'through' => $through->getRegistryAlias(),
                'foreignKey' => 'left_id',
                'targetForeignKey' => 'right_id',
                'conditions' => [
                    $through->aliasField('relation_id') => $relation->id,
                    sprintf('%s.deleted', $relation->alias) => false,
                ],
                'sort' => [
                    $through->aliasField('priority') => 'asc',
                ],
            ]);
        }

        // Add relations to the right side.
        foreach ($objectType->getRelations('right') as $relation) {
            if ($this->getTable()->association($relation->inverse_alias) !== null) {
                continue;
            }

            $className = 'BEdita/Core.Objects';
            if (count($relation->left_object_types) === 1) {
                $className = $relation->left_object_types[0]->table;
            }

            $through = TableRegistry::get(
                $relation->inverse_alias . 'ObjectRelations',
                ['className' => 'ObjectRelations']
            );
            $through->getValidator()->setProvider(
                'jsonSchema',
                Dereferencer::draft4()->dereference(json_decode(json_encode($relation->params)))
            );

            $this->relatedTo($relation->inverse_alias, [
                'className' => $className,
                'through' => $through->getRegistryAlias(),
                'foreignKey' => 'right_id',
                'targetForeignKey' => 'left_id',
                'conditions' => [
                    $through->aliasField('relation_id') => $relation->id,
                    sprintf('%s.deleted', $relation->inverse_alias) => false,
                ],
                'sort' => [
                    $through->aliasField('inv_priority') => 'asc',
                ],
            ]);
        }
    }

    /**
     * Get a list of all available relations indexed by their name with regards of side.
     *
     * @return \BEdita\Core\Model\Entity\Relation[]
     * @deprecated Use `ObjectType::getRelations()` instead.
     */
    public function getRelations()
    {
        return $this->objectType()->getRelations();
    }
}