Returns objects lists table with attributes list and values

@param type $objectType
@param type $attributes
@return type $statement
774922
final public function getObjectsList($objectType, $properties = array(), $objectURI = NULL, $objectId = NULL)
    {

        if (empty($properties)):
            if (!empty($this->propertyModel))
                $properties = array_keys($this->propertyModel);
        endif;

        $query = static::getObjectQuery($properties, "?{$this->valueGroup}property_values", NULL, $objectType, $objectURI, $objectId);

        //echo($this->withConditions) ;
        $query .= "\nGROUP BY o.object_id";
        $query .= $this->getListLookUpConditionsClause();
        $query .= $this->getListOrderByStatement();
        $query .= $this->getLimitClause();

        $total = $this->getObjectsListCount($objectType, $properties, $objectURI, $objectId); //Count first
        $results = $this->database->prepare($query)->execute();
        //Could use SQL_CALC_FOUND here but just the same as just using a second query really;
        //$queries = $this->database->getQueryLog();
        $this->resetListLookUpConditions();
        $this->setListTotal($total);

        return $results;
    }
119943
public JSONObject getObjects(List<String> objectIDs, List<String> attributesToRetrieve) throws AlgoliaException {
    return this.getObjects(objectIDs, attributesToRetrieve, RequestOptions.empty);
  }
786770
public function tableAttributes(array $attributes = array()): Builder
    {
        array_set($attributes, 'id', array_get($attributes, 'id') . str_random(3));
        $this->tableAttributes = array_merge($this->tableAttributes, $attributes);
        return $this;
    }
695158
def get_objects_with_attribute(self, obj_type, attribute, value):
        
        return [o for o in self.get_objects_by_type(obj_type) if o.get_attribute(attribute) == value]
1215035
public function getObjectsByPropertyValueBetween($property, $valueA, $valueB, array $select, $objectType = NULL, $objectURI = NULL, $objectId = NULL)
    {

        if (empty($property) || empty($valueA) || empty($valueB) || empty($select))
            return false; //We must have eactly one property value pair defined 

        $query = static::getObjectQuery($select, "?{$this->valueGroup}property_values", $objectId, $objectType, $objectURI);

        $query .= "\nGROUP BY o.object_id";
        $query .= "\nHAVING {$property} BETWEEN {$valueA} AND {$valueB}"; //@TODO check if we are comparing dates and use CAST() to convert to dates 


        $results = $this->database->prepare($query)->execute();

        return $results;
    }
360397
private function processDeserializeTypeCollectionObject(Type\Collection\Object $objectType, $object, array $values)
    {
        $objects = [];
        foreach ($values as $key => $objectFromValue) {
            $objects[$key] = $this->setObjectForClass($objectType->className(), $objectFromValue);
        }

        $object->{$objectType->setter()}($objects);

        return $this;
    }
99569
public static function canAny($action, $objectType)
    {
        if (!isset($_SESSION['ACL_INFO'])) {
            return false;
        };
        $acl = $_SESSION['ACL_INFO'];
        foreach (array('*', $action) as $act) {
            if (array_key_exists($act, $acl)) {
                $acl2 = $acl[$act];
                foreach (array('*', $objectType) as $typ) {
                    if (array_key_exists($typ, $acl2)) {
                        foreach ($acl2[$typ] as $id) {
                            return true;
                        };
                    };
                };
            };
        };
        return false;
    }
171734
public function newLdapEntry(array $attributes = [])
    {
        $objectClass = $this->schema->objectClass();

        if (array_key_exists($objectClass, $attributes) && array_key_exists(0, $attributes[$objectClass])) {
            // Retrieve all of the object classes from the LDAP
            // entry and lowercase them for comparisons.
            $classes = array_map('strtolower', $attributes[$objectClass]);

            // Retrieve the model mapping.
            $models = $this->schema->objectClassModelMap();

            // Retrieve the object class mappings (with strtolower keys).
            $mappings = array_map('strtolower', array_keys($models));

            // Retrieve the model from the map using the entry's object class.
            $map = array_intersect($mappings, $classes);

            if (count($map) > 0) {
                // Retrieve the model using the object class.
                $model = $models[current($map)];

                // Construct and return a new model.
                return $this->newModel([], $model)
                    ->setRawAttributes($attributes);
            }
        }

        // A default entry model if the object class isn't found.
        return $this->newModel()->setRawAttributes($attributes);
    }
943442
public static function getObjectUsers($action, $objectType, $objectId)
    {
        global $PPHP;
        $db = $PPHP['db'];

        $out = $db->selectList(
            "
            SELECT userId FROM acl_users
            WHERE action=? AND objectType=? AND objectId=?
            ORDER BY userId ASC
            ",
            array(
                $action,
                $objectType,
                $objectId
            )
        );
        return (is_array($out) ? $out : array());
    }
546146
public JSONObject getObject(String objectID, List<String> attributesToRetrieve) throws AlgoliaException {
    return this.getObject(objectID, attributesToRetrieve, RequestOptions.empty);
  }
810176
private function getAttributeTableFieldItems(
        $attributeTables,
        $minProductId,
        $maxProductId,
        $storeIds,
        $attributeMapper
    ) {
        $attributeQueries = [];

        foreach ($attributeTables as $attributeTable) {
            $attributeQueries[] = $this->_resource->getConnection()->select()
                ->from($this->getTable($attributeTable), ['attribute_id', 'store_id', 'entity_id', 'value'])
                ->where('entity_id >= ?', $minProductId)
                ->where('entity_id <= ?', $maxProductId)
                ->where('store_id IN (?)', $storeIds)
                ->where('attribute_id IN (?)', $attributeMapper);
        }

        try {
            $unionQuery = $this->_resource->getConnection()->select()
                ->union($attributeQueries, \Zend_Db_Select::SQL_UNION_ALL); // @codingStandardsIgnoreLine
            $this->iterator->walk(
                (string)$unionQuery,
                [[$this, 'handleAttributeDataTable']],
                [
                    'attributeMapper' => $attributeMapper,
                ],
                $this->_resource->getConnection()
            );
        } catch (\Exception $e) { // @codingStandardsIgnoreLine
        }

        return $this;
    }
615438
public function overrideFields($objectType, $fields)
    {
        Splash::log()->trace();
        //====================================================================//
        // Check if Configuration is Empty
        if (empty($this->getConfiguration())) {
            return $fields;
        }
        //====================================================================//
        // Load Configuration from Configurator
        $overrides = $this->getConfigurationValue($objectType, "fields");
        //====================================================================//
        // Check if Configuration is an Array
        if (!is_array($overrides)) {
            return $fields;
        }
        //====================================================================//
        // Walk on Defined Fields
        foreach ($fields as $index => $field) {
            //====================================================================//
            // Check if Configuration Key Exists
            if (!isset($overrides[$field->id])) {
                continue;
            }
            //====================================================================//
            // Update Field Definition
            $fields[$index] = self::updateField($field, $overrides[$field->id]);
        }

        return $fields;
    }
258712
public function getAttributes(array $attribute_names = [], array $types = [])
    {
        $attribute_map = [];

        if (empty($attribute_names)) {
            $attribute_map = $this->attribute_map->getItems();
        } else {
            foreach ($attribute_names as $attribute_name) {
                $attribute_map[$attribute_name] = $this->getAttribute($attribute_name);
            }
        }

        if (!empty($types)) {
            $attribute_map = array_filter(
                $attribute_map,
                function ($attribute) use ($types) {
                    return in_array(get_class($attribute), $types);
                }
            );
        }

        return new AttributeMap($attribute_map);
    }
283601
private function getIdsWithAttributes($id, $attributes = [])
    {
        $ids = [];

        if ($id instanceof Model) {
            $ids[$id->getKey()] = $attributes;
        } elseif ($id instanceof Collection) {
            foreach ($id as $model) {
                $ids[$model->getKey()] = $attributes;
            }
        } elseif (is_array($id)) {
            foreach ($id as $key => $attributesArray) {
                if (is_array($attributesArray)) {
                    $ids[$key] = array_merge($attributes, $attributesArray);
                } else {
                    $ids[$attributesArray] = $attributes;
                }
            }
        } elseif (is_int($id) || is_string($id)) {
            $ids[$id] = $attributes;
        }

        $idsOnly = array_keys($ids);

        return [$idsOnly, $ids];
    }
856073
public function getAttributeItems($attribute, $type = 0, $json = false, $default = false) {
		$cacheName = '_attribute' . $this->_attributeItemTypes[$type] . 'ItemsList';
		if(!isset($this->$cacheName[$attribute])) {
			$this->cacheAttributeItems($attribute);
		}

		if($type) {
			$items = $this->$cacheName[$attribute];

			return $json ? Json::encode($items) : $items;
		}

		$scenario = $default ? '_default' : $this->scenario;
		$attributeItems = $this->$cacheName[$attribute];
		$items = isset($attributeItems[$scenario]) ? $attributeItems[$scenario] : [];

		return $json ? Json::encode($items) : $items;
	}
506800
public function findObjectPics($object_type, $object_id)
    {
        $query = $this->db()->createQueryBuilder();
        return $query->select('*')
            ->from($this->table, 'p')
            ->where('p.object_type = ?')
            ->andWhere(('p.object_id = ?'))
            ->setParameter(0, $object_type)
            ->setParameter(1, $object_id)
            ->execute();
    }
1088573
public function batchReadByID(array $objectTypeIDs) {
        $requests = [];

        foreach ($objectTypeIDs as $objectTypeID) {
            $requests[] = [
                'method' => 'cmdb.object_type_categories.read',
                'params' => [
                    'type' => $objectTypeID
                ]
            ];
        }

        return $this->api->batchRequest($requests);
    }