bytic / orm

src/Relations/HasAndBelongsToMany.php

<?php

namespace Nip\Records\Relations;

use Nip\Database\Query\AbstractQuery;
use Nip\Database\Query\Delete as DeleteQuery;
use Nip\Database\Query\Insert as InsertQuery;
use Nip\Database\Query\Select as SelectQuery;
use Nip\HelperBroker;
use Nip\Records\Collections\Collection as RecordCollection;
use Nip\Records\Record;
use Nip\Records\Relations\Traits\HasPivotTable;

/**
 * Class HasAndBelongsToMany
 * @package Nip\Records\Relations
 */
class HasAndBelongsToMany extends HasOneOrMany
{
    use HasPivotTable;

    /**
     * @var string
     */
    protected $type = 'hasAndBelongsToMany';

    /**
     * @var null
     */
    protected $joinFields = null;

    /**
     * @inheritdoc
     */
    public function addParams($params)
    {
        parent::addParams($params);
        $this->addPivotParams($params);
    }

    /** @noinspection PhpMissingParentCallCommonInspection
     * @return SelectQuery
     * @throws \Exception
     */
    public function newQuery()
    {
        $query = $this->getDB()->newSelect();

        $query->from($this->getWith()->getFullNameTable());

$this->getWith()->getFullNameTable() of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

        $query->from($this->getDB()->getDatabase() . '.' . $this->getTable());

        foreach ($this->getWith()->getFields() as $field) {

Are you sure the usage of $this->getWith()->getFields() targeting Nip\Records\AbstractModels\RecordManager::getFields() seems to always return null.

The expression $this->getWith()->getFields() of type null is not traversable.

            $query->cols(["{$this->getWith()->getTable()}.$field", $field]);
        }

        foreach ($this->getJoinFields() as $field) {
            $query->cols(["{$this->getTable()}.$field", "__$field"]);
        }

        $this->hydrateQueryWithPivotConstraints($query);

        $order = $this->getParam('order');
        if (is_array($order)) {

The condition is_array($order) is always false.

            foreach ($order as $item) {
                $query->order([$item[0], $item[1]]);
            }
        }

        return $query;
    }

    /**
     * @return null|array
     */
    protected function getJoinFields()
    {
        if ($this->joinFields == null) {
            $this->initJoinFields();
        }

        return $this->joinFields;
    }

    /**
     * @param null $joinFields

Are you sure the doc-type for parameter $joinFields is correct as it would always require null to be passed?

     */
    public function setJoinFields($joinFields)
    {
        $this->joinFields = $joinFields;
    }

    protected function initJoinFields()
    {
        $structure = $this->getDB()->getMetadata()->describeTable($this->getTable());
        $this->setJoinFields(array_keys($structure["fields"]));
    }

    /**
     * @inheritdoc
     */
    public function populateQuerySpecific(AbstractQuery $query)
    {
        $pk1 = $this->getPrimaryKey();
        $fk1 = $this->getFK();

        $query->where("`{$this->getTable()}`.`$fk1` = ?", $this->getItem()->{$pk1});

        return $query;
    }

    /**
     * Simple select query from the link table
     * @param bool $specific
     * @return SelectQuery
     */
    public function getLinkQuery($specific = true)
    {
        $query = $this->getDB()->newSelect();
        $query->from($this->getTable());

$this->getTable() of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

        if ($specific) {
            $query = $this->populateQuerySpecific($query);
        }

        return $query;
    }

    /** @noinspection PhpMissingParentCallCommonInspection
     * @param RecordCollection $collection
     * @return RecordCollection
     */
    public function getEagerResults($collection)
    {
        if ($collection->count() < 1) {
            return $this->getWith()->newCollection();
        }

        $query = $this->getEagerQuery($collection);

        $return = $this->newCollection();
        $results = $this->getDB()->execute($query);
        if ($results->numRows() > 0) {
            $i = 1;
            $rows = $results->fetchResults();
            foreach ($rows as $row) {
                $row['relation_key'] = $i++;
                $item = $this->getWith()->getNew($row);
                $return->add($item, 'relation_key');
            }
        }

        return $return;
    }

    /** @noinspection PhpMissingParentCallCommonInspection
     * @return $this
     */
    public function save()
    {
        $this->deleteConnections();
        $this->saveConnections();

        return $this;
    }

    protected function deleteConnections()
    {
        $query = $this->newDeleteQuery();
        $query->where(
            "{$this->getFK()} = ?",
            $this->getItemRelationPrimaryKey()
        );
//        echo $query;
        $query->execute();
    }

    /**
     * @return DeleteQuery
     */
    protected function newDeleteQuery()
    {
        $query = $this->getDB()->newDelete();
        $query->table($this->getTable());

$this->getTable() of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::table().

        return $query;
    }

    protected function saveConnections()
    {
        if ($this->hasResults()) {
            $query = $this->newInsertQuery();
            $this->queryAttachRecords($query, $this->getResults());
//            echo $query;
            $query->execute();
        }
    }

    /**
     * @return InsertQuery
     */
    protected function newInsertQuery()
    {
        $query = $this->getDB()->newInsert();
        $query->table($this->getTable());

$this->getTable() of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::table().

        return $query;
    }

    /**
     * @param InsertQuery $query
     * @param $records
     */
    protected function queryAttachRecords($query, $records)
    {
        foreach ($records as $record) {
            $data = $this->formatAttachData($record);
            foreach ($this->getJoinFields() as $field) {
                if ($record->{"__$field"}) {
                    $data[$field] = $record->{"__$field"};
                } else {
                    $data[$field] = $data[$field] ? $data[$field] : false;
                }
            }
            $query->data($data);
        }
    }

    /**
     * @param $record
     * @return array
     */
    protected function formatAttachData($record)
    {
        $data = [
            $this->getManager()->getPrimaryFK() => $this->getItem()->{$this->getManager()->getPrimaryKey()},
            $this->getPivotFK() => $record->{$this->getWith()->getPrimaryKey()},
        ];
        return $data;
    }

    /**
     * @param $model
     */
    public function attach($model)
    {
        $query = $this->newInsertQuery();
        $this->queryAttachRecords($query, [$model]);
//            echo $query;
        $query->execute();
    }

    /**
     * @param Record $model
     */
    public function detach($model)
    {
        $query = $this->newDeleteQuery();
        $this->queryDetachRecords($query, [$model]);
//        echo $query;
        $query->execute();
    }

    /**
     * @param DeleteQuery $query
     * @param $records
     */
    protected function queryDetachRecords($query, $records)
    {
        $ids = HelperBroker::get('Arrays')->pluck($records, $this->getWith()->getPrimaryKey());

The method pluck() does not exist on Nip\Helpers\AbstractHelper. It seems like you code against a sub-type of Nip\Helpers\AbstractHelper such as Nip_Helper_Url or Nip_Helper_Arrays or Nip\Helpers\View\Stylesheets or Nip\Helpers\View\Strings or Nip\Helpers\View\Paginator or Nip\Helpers\View\Arrays or Nip\Helpers\View\Icontext or Nip\Helpers\View\Color or Nip\Helpers\View\Scripts or Nip\Helpers\View\Url.

        $query->where(
            "{$this->getPivotFK()} IN ?",
            $ids
        );

        $query->where(
            "{$this->getFK()} = ?",
            $this->getItemRelationPrimaryKey()
        );
    }


    /** @noinspection PhpMissingParentCallCommonInspection
     * @return mixed
     */
    public function getWithClass()
    {
        return $this->getName();
    }

    /** @noinspection PhpMissingParentCallCommonInspection
     * @return string
     */
    protected function getDictionaryKey()
    {
        return '__' . $this->getFK();
    }
}