samsoncms\api\Material

Complexity

Total Complexity

69

Size/Duplication

Total Lines	610
Duplicated Lines	21.15 %

Coupling/Cohesion

Components	2
Dependencies	7

Importance

Changes	21
Bugs	6	Features	9

17 Methods

Rating	Name	Duplication	Size	Complexity
B	idsByFieldValue()	0	31	4
A	byFieldValue()	11	11	3
A	byNavigationID()	11	11	3
A	amountByNavigationID()	11	11	3
A	byNavigationIdAndFieldValue()	18	18	4
A	amountByNavigationIdAndFieldValue()	18	18	4
B	setFieldByID()	0	28	3
A	selectText()	0	14	3
B	gallery()	0	32	5
A	idsByNavigationID()	22	22	3
A	byIDs()	11	11	2
A	byUrl()	11	11	2
A	copyRelatedEntity()	0	15	3
A	copy()	0	14	1
A	nestedIDs()	0	19	2
C	table()	8	66	11
D	getTable()	8	97	13

<?php
/**
 * Created by Vitaly Iegorov <egorov@samsonos.com>
 * on 07.08.14 at 17:11
 */
namespace samsoncms\api;

use samson\activerecord\dbQuery;
use \samsonframework\orm\Condition;
use samsonframework\orm\Query;
use \samsonframework\orm\QueryInterface;

/**
 * SamsonCMS Material database record object.
 * This class extends default ActiveRecord material table record functionality.
 * @package samson\cms
 * @author Vitaly Egorov <egorov@samsonos.com>
 */
class Material extends \samson\activerecord\material
{
    /** Override table attributes for late static binding */
    public static $_attributes = array();
    public static $_sql_select = array();
    public static $_sql_from = array();
    public static $_own_group = array();
    public static $_map = array();

    /** @var integer Primary field */
    public $MaterialID;

    /** @var string Unique identifier */
    public $Url;

    /** @var bool Internal existence flag */
    public $Active;

    /**
     * Get identifiers collection by field identifier and its value.
     * Method is optimized for performance.
     *
     * @param QueryInterface $query Database query instance
     * @param string $fieldID Additional field identifier
     * @param string $fieldValue Additional field value for searching
     * @param array|null $return Variable where request result would be returned
     * @param array $materialIDs Collection of material identifiers for filtering query
     * @return bool|array True if material entities has been found and $return is passed
     *                      or identifiers collection if only two parameters is passed.
     */
    public static function idsByFieldValue(
        QueryInterface $query,
        $fieldID,
        $fieldValue,
        &$return = array(),
        $materialIDs = null
    ) {
        /** @var Field $fieldRecord We need to have field record */
        $fieldRecord = null;
        if (Field::byID($query, $fieldID, $fieldRecord)) {

$fieldRecord is of type object<samsoncms\api\Field>, but the function expects a null|object<self>.

            $materials = array();

            // Get material identifiers by field
            $query->entity(CMS::MATERIAL_FIELD_RELATION_ENTITY)
                ->where('MaterialID', $materials)

$materials is of type array, but the function expects a string|null.

                ->where('Active', 1)
                ->where('FieldID', $fieldID)
                ->where($fieldRecord->valueFieldName(), $fieldValue);

            // Add material identifier filter if passed
            if (isset($materialIDs)) {
                $query->where('MaterialID', $materialIDs);

$materialIDs is of type array, but the function expects a string|null.

            }

            // Perform database query and get only material identifiers collection
            $return = $query->fields('MaterialID');
        }

        // If only one argument is passed - return null, otherwise bool
        return func_num_args() > 3 ? sizeof($return) : $return;
    }

    /**
     * Get current entity identifiers collection by navigation identifier.
     *
     * @param QueryInterface $query Database query
     * @param string $navigationID Navigation identifier
     * @param array $return Variable where request result would be returned
     * @param array $materialIDs Collection of material identifiers for filtering query
     * @return bool|array True if material entities has been found and $return is passed
     *                      or collection of identifiers if only two parameters is passed.
     */
    public static function idsByNavigationID(

This method seems to be duplicated in your project.

        QueryInterface $query,
        $navigationID,
        &$return = array(),
        $materialIDs = null
    ) {
        // Prepare query
         $query->entity(CMS::MATERIAL_NAVIGATION_RELATION_ENTITY)
            ->where('StructureID', $navigationID)
            ->where('Active', 1);

        // Add material identifier filter if passed
        if (isset($materialIDs)) {
            $query->where('MaterialID', $materialIDs);

$materialIDs is of type array, but the function expects a string|null.

        }

        // Perform database query and get only material identifiers collection
        $return = $query->fields('MaterialID');

        // If only one argument is passed - return null, otherwise bool
        return func_num_args() > 2 ? sizeof($return) : $return;
    }

    /**
     * Get current entity instances collection by their identifiers.
     * Method can accept different query executors.
     *
     * @param QueryInterface $query Database query
     * @param string|array $materialIDs Material identifier or their colleciton
     * @param self[]|array|null $return Variable where request result would be returned
     * @param string $executor Method name for query execution
     * @return bool|self[] True if material entities has been found and $return is passed
     *                      or self[] if only two parameters is passed.
     */
    public static function byIDs(QueryInterface $query, $materialIDs, &$return = array(), $executor = 'exec')

This method seems to be duplicated in your project.

    {
        $return = $query->entity(get_called_class())
            ->where('MaterialID', $materialIDs)

It seems like $materialIDs defined by parameter $materialIDs on line 125 can also be of type array; however, samsonframework\orm\QueryInterface::where() does only seem to accept string|null, maybe add an additional type check?

            ->where('Active', 1)
            ->where('Published', 1)
            ->$executor();

        // If only one argument is passed - return null, otherwise bool
        return func_num_args() > 2 ? sizeof($return) : $return;
    }

    /**
     * Get self[] by field identifier and its value.
     * Method is optimized for performance.
     *
     * @param QueryInterface $query Database query instance
     * @param string $fieldID Additional field identifier
     * @param string $fieldValue Additional field value for searching
     * @param self[]|array|null $return Variable where request result would be returned
     * @return bool|self[] True if material entities has been found and $return is passed
     *                      or self[] if only two parameters is passed.
     */
    public static function byFieldValue(QueryInterface $query, $fieldID, $fieldValue, &$return = array())

This method seems to be duplicated in your project.

    {
        /** @var array $materialIds Collection of entity identifiers filtered by additional field */
        $materialIds = null;
        if (static::idsByFieldValue($query, $fieldID, $fieldValue, $materialIds)) {
            static::byIDs($query, $materialIds, $return);

It seems like $materialIds defined by null on line 151 can also be of type null; however, samsoncms\api\Material::byIDs() does only seem to accept string|array, maybe add an additional type check?

        }

        // If only one argument is passed - return null, otherwise bool
        return func_num_args() > 3 ? sizeof($return) : $return;
    }

    /**
     * Get current entity instances collection by navigation identifier.
     *
     * @param QueryInterface $query Database query
     * @param string $navigationID Navigation identifier
     * @param self[]|array|null $return Variable where request result would be returned
     * @return bool|self[] True if material entities has been found and $return is passed
     *                      or self[] if only two parameters is passed.
     */
    public static function byNavigationID(QueryInterface $query, $navigationID, &$return = array())

This method seems to be duplicated in your project.

    {
        /** @var array $materialIds Collection of entity identifiers filtered by additional field */
        $materialIds = null;
        if (static::idsByNavigationID($query, $navigationID, $materialIds)) {
            static::byIDs($query, $materialIds, $return);
        }

        // If only one argument is passed - return null, otherwise bool
        return func_num_args() > 2 ? sizeof($return) : $return;
    }

    /**
     * Get current entity instances amount by navigation identifier.
     *
     * @param QueryInterface $query Database query
     * @param string $navigationID Navigation identifier
     * @param self[]|array|null $return Variable where request result would be returned
     * @return bool|self[] True if material entities has been found and $return is passed
     *                      or self[] if only two parameters is passed.
     */
    public static function amountByNavigationID(QueryInterface $query, $navigationID, &$return = array())

This method seems to be duplicated in your project.

    {
        /** @var array $materialIds Collection of entity identifiers filtered by additional field */
        $materialIds = null;
        if (static::idsByNavigationID($query, $navigationID, $materialIds)) {
            static::byIDs($query, $materialIds, $return, 'count');
        }

        // If only one argument is passed - return null, otherwise bool
        return func_num_args() > 2 ? sizeof($return) : $return;
    }

    /**
     * Get current entity instances collection by navigation identifier and additional field value.
     *
     * @param QueryInterface $query Database query
     * @param string $navigationID Navigation identifier
     * @param string $fieldID Additional field identifier
     * @param string $fieldValue Additional field value for searching
     * @param self[]|array|null $return Variable where request result would be returned
     * @return bool|self[] True if material entities has been found and $return is passed
     *                      or self[] if only two parameters is passed.
     */
    public static function byNavigationIdAndFieldValue(

This method seems to be duplicated in your project.

        QueryInterface $query,
        $navigationID,
        $fieldID,
        $fieldValue,
        &$return = array()
    ) {
        /** @var array $materialIds Collection of entity identifiers filtered by additional field */
        $materialIds = null;
        if (static::idsByNavigationID($query, $navigationID, $materialIds)) {
            if (static::idsByFieldValue($query, $fieldID, $fieldValue, $materialIds, $materialIds)) {
                static::byIDs($query, $materialIds, $return);

It seems like $materialIds defined by null on line 221 can also be of type null; however, samsoncms\api\Material::byIDs() does only seem to accept string|array, maybe add an additional type check?

            }
        }

        // If only one argument is passed - return null, otherwise bool
        return func_num_args() > 4 ? sizeof($return) : $return;
    }

    /**
     * Get current entity instances amount by navigation identifier and additional field value.
     *
     * @param QueryInterface $query Database query
     * @param string $navigationID Navigation identifier
     * @param string $fieldID Additional field identifier
     * @param string $fieldValue Additional field value for searching
     * @param self[]|array|null $return Variable where request result would be returned
     * @return bool|self[] True if material entities has been found and $return is passed
     *                      or self[] if only two parameters is passed.
     */
    public static function amountByNavigationIdAndFieldValue(

This method seems to be duplicated in your project.

        QueryInterface $query,
        $navigationID,
        $fieldID,
        $fieldValue,
        &$return = array()
    ) {
        /** @var array $materialIds Collection of entity identifiers filtered by additional field */
        $materialIds = null;
        if (static::idsByNavigationID($query, $navigationID, $materialIds)) {
            if (static::idsByFieldValue($query, $fieldID, $fieldValue, $materialIds, $materialIds)) {
                static::byIDs($query, $materialIds, $return, 'count');

It seems like $materialIds defined by null on line 251 can also be of type null; however, samsoncms\api\Material::byIDs() does only seem to accept string|array, maybe add an additional type check?

            }
        }

        // If only one argument is passed - return null, otherwise bool
        return func_num_args() > 4 ? sizeof($return) : $return;
    }

    /**
     * Get material entity by URL(s).
     *
     * @param QueryInterface $query Object for performing database queries
     * @param array|string $url Material URL or collection of material URLs
     * @param self|array|null $return Variable where request result would be returned
     * @return bool|self True if material entities has been found
     */
    public static function byUrl(QueryInterface $query, $url, & $return = array())

This method seems to be duplicated in your project.

    {
        // Get entities by filtered identifiers
        $return = $query->entity(get_called_class())
            ->where('Url', $url)

It seems like $url defined by parameter $url on line 270 can also be of type array; however, samsonframework\orm\QueryInterface::where() does only seem to accept string|null, maybe add an additional type check?

            ->where('Active', 1)
            ->first();

        // If only one argument is passed - return null, otherwise bool
        return func_num_args() > 2 ? $return !== null : $return;
    }

    /**
     * Set additional material field value by field identifier
     * @param string $fieldID Field identifier
     * @param string $value Value to be stored
     * @param string $locale Locale identifier
     */
    public function setFieldByID($fieldID, $value, $locale = DEFAULT_LOCALE)
    {
        // TODO: This should be removed
        /** @var QueryInterface $query This should be removed to use $this->database*/
        $query = dbQuery();

The call to dbQuery() misses a required argument $class_name.

        /** @var Field $fieldRecord Try to find this additional field */
        $fieldRecord = null;
        if (Field::byID($query, $fieldID, $fieldRecord)) {

$fieldRecord is of type object<samsoncms\api\Field>, but the function expects a null|object<self>.

            /** @var MaterialField[] $materialFieldRecord Try to find additional field value */
            $materialFieldRecord = null;
            if (!MaterialField::byFieldIDAndMaterialID($query, $this->id, $fieldRecord->id, $materialFieldRecord)) {
                // Create new additional field value record if it does not exists
                $materialFieldRecord = new MaterialField();
                $materialFieldRecord->FieldID = $fieldRecord->id;
                $materialFieldRecord->MaterialID = $this->id;
                $materialFieldRecord->Active = 1;

The property $Active was declared of type boolean, but 1 is of type integer. Maybe add a type cast?

                $materialFieldRecord->locale = $locale;
            } else { // Get first record(actually it should be only one)
                $materialFieldRecord = array_shift($materialFieldRecord);
            }

            // At this point we already have database record instance
            $valueFieldName = $fieldRecord->valueFieldName();
            $materialFieldRecord->$valueFieldName = $value;
            $materialFieldRecord->save();
        }
    }

    /**
     * Get select additional field text value.
     *
     * @param string $fieldID Field identifier
     * @return string Select field text
     */
    public function selectText($fieldID)
    {
        /** @var Field $field */
        $field = null;
        if (Field::byID(new Query('\samsoncms\api\Field', $this->database), $fieldID, $fieldID)) {

$fieldID is of type string, but the function expects a null|object<self>.

            // If this entity has this field set
            if (isset($this[$field->Name]{0})) {
                return $field->options($this[$field->Name]);
            }
        }

        // Value not set
        return '';
    }

    /**
     * Get collection of images for material by gallery additional field selector. If none is passed
     * all images from gallery table would be returned for this material entity.
     *
     * @param string|null $fieldSelector Additional field selector value
     * @param string $selector Additional field field name to search for
     * @return \samsonframework\orm\RecordInterface[] Collection of images in this gallery additional field for material
     */
    public function &gallery($fieldSelector = null, $selector = 'FieldID')
    {
        /** @var \samsonframework\orm\RecordInterface[] $images Get material images for this gallery */
        $images = array();

        // Create query
        $query = new dbQuery();

        $query->entity(CMS::MATERIAL_FIELD_RELATION_ENTITY);

        /* @var Field Get field object if we need to search it by other fields */
        $field = null;
        if ($selector != 'FieldID' && Field::oneByColumn($query, $selector, $fieldSelector)) {
            $fieldSelector = $field->id;
        }

        // Add field filter if present
        if (isset($fieldSelector)) {
            $query->where("FieldID", $fieldSelector);
        }

        /** @var \samson\activerecord\materialfield $dbMaterialField Find material field gallery record */
        $dbMaterialField = null;
        if ($query->where('MaterialID', $this->id)->first($dbMaterialField)) {
            // Get material images for this materialfield
            $images = $query->entity(CMS::MATERIAL_IMAGES_RELATION_ENTITY)
                ->where('materialFieldId', $dbMaterialField->id)
                ->exec();
        }

        return $images;
    }

    /**
     * Copy this material related entities.
     *
     * @param QueryInterface $query Database query instance
     * @param string $entity Entity identifier
     * @param string $newIdentifier Copied material idetifier
     * @param array $excludedIDs Collection of related entity identifier to exclude from copying
     */
    protected function copyRelatedEntity(QueryInterface $query, $entity, $newIdentifier, $excludedIDs = array())
    {
        // Copy additional fields
        foreach ($query->entity($entity)

The expression $query->entity($entity)->where('MaterialID', $this->MaterialID)->exec() of type boolean|object<samsonframework\orm\RecordInterface> is not guaranteed to be traversable. How about adding an additional type check?

                     ->where('MaterialID', $this->MaterialID)
                     ->exec() as $copiedEntity) {
            // Check if field is NOT excluded from copying
            if (!in_array($copiedEntity->id, $excludedIDs)) {
                /** @var MaterialField $copy Copy instance */
                $copy = $copiedEntity->copy();
                $copy->MaterialID = $newIdentifier;

The property $MaterialID was declared of type integer, but $newIdentifier is of type string. Maybe add a type cast?

                $copy->save();
            }
        }
    }

    /**
     * Create copy of current object.
     *
     * @param mixed $clone Material for cloning
     * @param array $excludedFields Additional fields identifiers not copied
     * @returns self New copied instance
     */
    public function &copy(&$clone = null, $excludedFields = array())
    {
        /** @var Material $clone Create new instance by copying */
        $clone = parent::copy($clone);

        // Create query
        $query = new dbQuery();

        $this->copyRelatedEntity($query, CMS::MATERIAL_NAVIGATION_RELATION_ENTITY, $clone->id);
        $this->copyRelatedEntity($query, CMS::MATERIAL_FIELD_RELATION_ENTITY, $clone->id, $excludedFields);
        $this->copyRelatedEntity($query, CMS::MATERIAL_IMAGES_RELATION_ENTITY, $clone->id);

        return $clone;
    }

    public function nestedIDs($navigationID = null, &$return = array())
    {
        // Create query
        $query = new dbQuery();

        /** @var array $nestedIDs Get collection of materials by navigation */
        $nestedIDs = null;
        if (static::idsByNavigationID($query, $navigationID, $nestedIDs)) {
            // Get collection of nested materials
            $return = $query->entity(get_class($this))
                ->where('MaterialID', $nestedIDs)

$nestedIDs is of type array, but the function expects a string|null.

                ->where('Active', 1)
                ->where('parent_id', $this->id)
                ->orderBy('priority')
                ->fields('MaterialID');
        }

        return $return;
    }

    /**
     * Get material additional fields table.
     *
     * @param string $navigationID Navigation table identifier
     * @param array $tableColumns Columns names list
     * @param string $externalHandler External handler to perform some extra code

There is no parameter named $externalHandler. Was it maybe removed?

     * @param array $params External handler params

There is no parameter named $params. Was it maybe removed?

     * @return array Collection of collections of table cells, represented as materialfield objects
     */
    public function table($navigationID, &$tableColumns = null) {
        // Create query
        $query = new dbQuery();

        /** @var array $resultTable Collection of collections of field cells */
        $resultTable = array();

        /** @var array $dbTableFieldsIds Array of table structure column identifiers */
        $dbTableFieldsIds = array();
        if (Field::byNavigationID($query, $navigationID, $dbTableFieldsIds)) {
            // Get localized and not localized fields
            $localizedFields = array();
            $unlocalizedFields = array();

            /** @var Field $field Table column */
            foreach ($dbTableFieldsIds as $field) {

The expression $dbTableFieldsIds of type array|null is not guaranteed to be traversable. How about adding an additional type check?

                /** Add table columns names */
                $tableColumns[] = $field->Name;
                if ($field->local == 1) {

This code seems to be duplicated across your project.

                    $localizedFields[] = $field->id;
                } else {
                    $unlocalizedFields[] = $field->id;
                }
            }

            // Get table row materials
            $tableRowsIDs = array();
            if ($this->nestedIDs($navigationID, $tableRowsIDs)) {
                // Create field condition
                $localizationFieldCond = new Condition('or');

                // Create localized condition
                if (sizeof($localizedFields)) {
                    $localizedFieldCond = new Condition('and');
                    $localizedFieldCond->add('FieldID', $localizedFields)
                        ->add('locale', locale());
                    // Add this condition to condition group
                    $localizationFieldCond->add($localizedFieldCond);

The call to add() misses a required argument $value.

$localizedFieldCond is of type object<samsonframework\orm\Condition>, but the function expects a string.

                }

                // Create not localized condition
                if (sizeof($unlocalizedFields)) {
                    $localizationFieldCond->add('FieldID', $unlocalizedFields);
                }// Create db query
                ;

                // Flip field identifiers as keys
                $tableColumnIds = array_flip($dbTableFieldsIds);
                $resultTable = array_flip($tableRowsIDs);

                /** @var \samson\activerecord\material $dbTableRow Material object (table row) */
                foreach ($query->entity(CMS::MATERIAL_FIELD_RELATION_ENTITY)
                             ->where('MaterialID', $tableRowsIDs)

$tableRowsIDs is of type array, but the function expects a string|null.

                             ->whereCondition($localizationFieldCond)->exec() as $mf) {
                    if (!is_array($resultTable[$mf['MaterialID']])) {

This code seems to be duplicated across your project.

                        $resultTable[$mf['MaterialID']] = array();
                    }

                    $resultTable[$mf['MaterialID']][$tableColumnIds[$mf->FieldID]] =
                        !empty($mf->Value) ? $mf->Value : (!empty($mf->numeric_value) ? $mf->numeric_value : $mf->key_value);
                }
            }
        }

        return array_values($resultTable);
    }

    /**
     * Function to retrieve this material table by specified field
     * @param string $tableSelector Selector to identify table structure
     * @param string $selector Database field by which search is performed
     * @param array $tableColumns Columns names list
     * @param string $externalHandler External handler to perform some extra code
     * @param array $params External handler params
     * @return array Collection of collections of table cells, represented as materialfield objects
     * @deprecated Use table()
     */
    public function getTable(
        $tableSelector,
        $selector = 'StructureID',
        &$tableColumns = null,
        $externalHandler = null,
        $params = array()
    ) {
        // Create query
        $query = new dbQuery();

$query is not used, you could remove the assignment.

        /** @var array $resultTable Collection of collections of field cells */
        $resultTable = array();
        /** @var array $dbTableFieldsIds Array of table structure column identifiers */
        $dbTableFieldsIds = array();

        // Get structure object if we need to search it by other fields
        if ($selector != 'StructureID') {
            $structure = dbQuery('structure')->cond($selector, $tableSelector)->first();

The method samson\activerecord\dbQuery::cond() has been deprecated with message: @see self::where()

            $tableSelector = $structure->id;
        }

        /** If this table has columns */
        if (dbQuery('structurefield')

The method samson\activerecord\dbQuery::cond() has been deprecated with message: @see self::where()

            ->cond("StructureID", $tableSelector)
            ->fields('FieldID', $dbTableFieldsIds)

$dbTableFieldsIds is of type array, but the function expects a string|null.

        ) {
            // Get localized and not localized fields
            $localizedFields = array();
            $unlocalizedFields = array();
            /** @var \samson\cms\CMSField $dbTableField Table column */
            foreach (dbQuery('field')->order_by('priority')->cond('FieldID', $dbTableFieldsIds)->exec() as $field) {

The method samson\activerecord\dbQuery::cond() has been deprecated with message: @see self::where()

                /** Add table columns names */
                $tableColumns[] = $field->Name;
                if ($field->local == 1) {

This code seems to be duplicated across your project.

                    $localizedFields[] = $field->id;
                } else {
                    $unlocalizedFields[] = $field->id;
                }
            }

            // Query to get table rows(table materials)
            $tableQuery = dbQuery('material')

The method samson\activerecord\dbQuery::cond() has been deprecated with message: @see self::where()

                ->cond('parent_id', $this->MaterialID)
                ->cond('Active', '1')
                ->join('structurematerial')
                ->cond('structurematerial_StructureID', $tableSelector)
                ->order_by('priority');

            // Call user function if exists
            if (is_callable($externalHandler)) {
                // Give it query as parameter
                call_user_func_array($externalHandler, array_merge(array(&$tableQuery), $params));
            }

            // Get table row materials
            $tableMaterialIds = array();
            if ($tableQuery->fields('MaterialID', $tableMaterialIds)) {
                // Create field condition
                $localizationFieldCond = new Condition('or');

                // Create localized condition
                if (sizeof($localizedFields)) {
                    $localizedFieldCond = new Condition('and');
                    $localizedFieldCond->add('materialfield_FieldID', $localizedFields)
                        ->add('materialfield_locale', locale());
                    // Add this condition to condition group
                    $localizationFieldCond->add($localizedFieldCond);

The call to add() misses a required argument $value.

$localizedFieldCond is of type object<samsonframework\orm\Condition>, but the function expects a string.

                }

                // Create not localized condition
                if (sizeof($unlocalizedFields)) {
                    $localizationFieldCond->add('materialfield_FieldID', $unlocalizedFields);
                }

                // Create db query
                $materialFieldQuery = dbQuery('materialfield')

The method samson\activerecord\dbQuery::cond() has been deprecated with message: @see self::where()

                    ->cond('MaterialID', $tableMaterialIds)

$tableMaterialIds is of type array, but the function expects a string|null.

                    ->cond($localizationFieldCond);

$localizationFieldCond is of type object<samsonframework\orm\Condition>, but the function expects a string|object<samson\activerecord\ConditionInterface>|object<samson\activerecord\ArgumentInterface>.

                // Flip field identifiers as keys
                $tableColumnIds = array_flip($dbTableFieldsIds);
                $resultTable = array_flip($tableMaterialIds);

                /** @var \samson\activerecord\material $dbTableRow Material object (table row) */
                foreach ($materialFieldQuery->exec() as $mf) {
                    if (!is_array($resultTable[$mf['MaterialID']])) {

This code seems to be duplicated across your project.

                        $resultTable[$mf['MaterialID']] = array();
                    }

                    $resultTable[$mf['MaterialID']][$tableColumnIds[$mf->FieldID]] =
                        !empty($mf->Value) ? $mf->Value : (!empty($mf->numeric_value) ? $mf->numeric_value : $mf->key_value);
                }
            }
        }

        return array_values($resultTable);
    }
}