manytomany.php

<?php
namespace Bitrix\Main\ORM\Fields\Relations;
 
use Bitrix\Main\ArgumentException;
use Bitrix\Main\ORM\Entity;
use Bitrix\Main\ORM\Fields\FieldTypeMask;
use Bitrix\Main\ORM\Query\Join;
use Bitrix\Main\ORM\Query\Query;
use Bitrix\Main\ORM\Fields\Relations\Reference;
use Bitrix\Main\SystemException;
use Bitrix\Main\Text\StringHelper;
 
class ManyToMany extends Relation
{
    protected $mediatorEntityName;
 
    protected $mediatorEntity;
 
    protected $mediatorTableName;
 
    protected $localPrimaryNames;
 
    protected $localReferenceName;
 
    protected $remotePrimaryNames;
 
    protected $remoteReferenceName;
 
    protected $joinType = Join::TYPE_LEFT;
 
    protected $cascadeSavePolicy = CascadePolicy::NO_ACTION;
 
    protected $cascadeDeletePolicy = CascadePolicy::NO_ACTION; // follow_orphans | no_action
 
    public function __construct($name, $referenceEntity)
    {
        if ($referenceEntity instanceof Entity)
        {
            $this->refEntity = $referenceEntity;
            $this->refEntityName = $referenceEntity->getFullName();
        }
        else
        {
            // this one could be without leading backslash and/or with Table-postfix
            $this->refEntityName = Entity::normalizeName($referenceEntity);
        }
 
        parent::__construct($name);
    }
 
    public function getTypeMask()
    {
        return FieldTypeMask::MANY_TO_MANY;
    }
 
    public function configureMediatorEntity($entity)
    {
        if ($entity instanceof Entity)
        {
            $this->mediatorEntity = $entity;
            $this->mediatorEntityName = $entity->getFullName();
        }
        else
        {
            // this one could be without leading backslash and/or with Table-postfix
            $this->mediatorEntityName = Entity::normalizeName($entity);
        }
 
        return $this;
    }
 
    public function configureMediatorTableName($name)
    {
        $this->mediatorTableName = $name;
 
        return $this;
    }
 
    public function configureTableName($name)
    {
        return $this->configureMediatorTableName($name);
    }
 
    public function configureLocalPrimary($fieldName, $mediatorFieldName)
    {
        $this->localPrimaryNames[$fieldName] = $mediatorFieldName;
 
        return $this;
    }
 
    public function configureLocalReference($name)
    {
        $this->localReferenceName = $name;
 
        return $this;
    }
 
    public function configureRemotePrimary($fieldName, $mediatorFieldName)
    {
        $this->remotePrimaryNames[$fieldName] = $mediatorFieldName;
 
        return $this;
    }
 
    public function configureRemoteReference($name)
    {
        $this->remoteReferenceName = $name;
 
        return $this;
    }
 
    public function getRemoteEntity()
    {
        return $this->getRefEntity();
    }
 
    public function getMediatorEntity()
    {
        if ($this->mediatorEntity === null)
        {
            if (!empty($this->mediatorEntityName) && Entity::has($this->mediatorEntityName))
            {
                $this->mediatorEntity = Entity::getInstance($this->mediatorEntityName);
            }
            else
            {
                // there is no described mediator entity
                // check table_name first, entity can not exist without it
                if (empty($this->mediatorTableName))
                {
                    throw new ArgumentException(sprintf(
                        'Table Name for mediator entity of relation `%s` between %s and %s was not found',
                        $this->name, $this->getEntity()->getObjectClass(), $this->getRefEntity()->getObjectClass()
                    ));
                }
 
                // generate mediator entity runtime
                if (empty($this->mediatorEntityName))
                {
                    $localEntityName = $this->getEntity()->getName();
                    $remoteEntityName = $this->getRefEntity()->getName();
                    $fieldToClassName = StringHelper::snake2camel($this->name);
 
                    // each field has its own entity in case of ManyToMany definitions will be different
                    $this->mediatorEntityName = "MediatorFrom{$localEntityName}To{$remoteEntityName}Via{$fieldToClassName}Table";
                }
 
                // fields of mediator entity
                $fields = [];
 
                // local entity primary
                $localReferenceConditions = Query::filter();
 
                foreach ($this->getEntity()->getPrimaryArray() as $primaryName)
                {
                    $mediatorPrimaryName = $this->localPrimaryNames[$primaryName] ?? $this->getLocalReferenceName().'_'.$primaryName;
 
                    $fieldType = get_class($this->getEntity()->getField($primaryName));
 
                    $mediatorPrimary = new $fieldType($mediatorPrimaryName);
                    $mediatorPrimary->configurePrimary(true);
 
                    $fields[] = $mediatorPrimary;
 
                    // save join condition for reference
                    $localReferenceConditions->whereColumn('this.'.$mediatorPrimaryName, 'ref.'.$primaryName);
                }
 
                // local reference
                $localReference = (new Reference($this->getLocalReferenceName(), $this->getEntity(), $localReferenceConditions))
                    ->configureJoinType($this->joinType);
                $fields[] = $localReference;
 
                // remote entity primary
                $remoteReferenceConditions = Query::filter();
 
                foreach ($this->getRefEntity()->getPrimaryArray() as $primaryName)
                {
                    $mediatorPrimaryName = $this->remotePrimaryNames[$primaryName] ?? $this->getRemoteReferenceName().'_'.$primaryName;
 
                    $fieldType = get_class($this->getRefEntity()->getField($primaryName));
 
                    $mediatorPrimary = new $fieldType($mediatorPrimaryName);
                    $mediatorPrimary->configurePrimary(true);
 
                    $fields[] = $mediatorPrimary;
 
                    // save join condition for reference
                    $remoteReferenceConditions->whereColumn('this.'.$mediatorPrimaryName, 'ref.'.$primaryName);
                }
 
                // remote reference
                $remoteReference = (new Reference($this->getRemoteReferenceName(), $this->getRefEntity(), $remoteReferenceConditions))
                    ->configureJoinType($this->joinType);
                $fields[] = $remoteReference;
 
                // set table name
                $parameters = ['table_name' => $this->mediatorTableName];
 
                // finalize
                $this->mediatorEntity = Entity::compileEntity($this->mediatorEntityName, $fields, $parameters);
            }
        }
 
        return $this->mediatorEntity;
    }
 
    public function getLocalReferenceName()
    {
        if (empty($this->localReferenceName))
        {
            $this->localReferenceName = strtoupper(StringHelper::camel2snake($this->getEntity()->getName()));
        }
 
        return $this->localReferenceName;
    }
 
    public function getLocalReference()
    {
        return $this->getMediatorEntity()->getField($this->getLocalReferenceName());
    }
 
    public function getRemoteReferenceName()
    {
        if (empty($this->remoteReferenceName))
        {
            $this->remoteReferenceName = strtoupper(StringHelper::camel2snake($this->getRefEntity()->getName()));
        }
 
        return $this->remoteReferenceName;
    }
 
    public function getRemoteReference()
    {
        return $this->getMediatorEntity()->getField($this->getRemoteReferenceName());
    }
}