/** * Create instance from reques * * @param string $method * @param null|int|string $id * @param array|\Illuminate\Contracts\Support\Arrayable $params * @return $this|array */ protected static function instanceFromRequest($method, $id = null, $params = []) { $response = static::requestToArray($method, $id, $params); if (Arr::isAssoc($response)) { return new static($response); } return Collection::makeOf(static::class, $response); }
public function getPostgisFields() { if (property_exists($this, 'postgisFields')) { return Arr::isAssoc($this->postgisFields) ? array_keys($this->postgisFields) : $this->postgisFields; //Returns the non-associative array that doesn't define the geometry type. } else { throw new PostgisFieldsNotDefinedException(__CLASS__ . ' has to define $postgisFields'); } }
/** * Builds a table-keyed array from model class names. * * @param string[]|null $models * @return array|null */ protected static function buildMorphMapFromModels(array $models = null) { if (is_null($models) || Arr::isAssoc($models)) { return $models; } $tables = array_map(function ($model) { return (new $model())->getEndpoint(); }, $models); return array_combine($tables, $models); }
public function setRows($rows = []) { if (Arr::isAssoc($rows)) { foreach ($rows as $key => $item) { $this->rows[] = [$key, $item]; } return $this; } $this->rows = $rows; return $this; }
/** * Get the fillable attributes for the model. * * @return array */ public function getFillable() { if ($fillable = $this->fillable) { if (Arr::isAssoc($fillable)) { return $fillable; } $keys = array_values($fillable); $types = array_fill(0, count($keys), 'string'); return array_combine($keys, $types); } }
/** * Send email the handler method * * @param int|static $resource * @param array $options * @return bool */ protected static function macroSendHandler($resource, ...$options) { if (static::isResource($resource)) { $resource = $resource->id; } if ($isAssoc = count($options) == 1 && Arr::isAssoc($options[0])) { $options = $options[0]; } if (!$isAssoc) { $options = ['emails' => $options]; } $response = static::request('POST', $resource . '/email', $options); return $response->getStatusCode() === 200; }
public function add($label, $data = [], $fillColor = '') { if (is_array($label)) { if (Arr::isAssoc($label)) { $this->data[] = $label; } else { foreach ($label as $item) { call_user_func_array([$this, 'add'], $item); } } return $this; } $this->data['datasets'][] = ['label' => $label, 'data' => $data, 'fillColor' => $fillColor]; return $this; }
/** * Prepare array elements for formatting. * * @param array $array * @return array */ protected static function prepareArrayLines(array $array) { $isAssoc = Arr::isAssoc($array); array_walk($array, function (&$value, $index, $withIndexes = false) { if (is_array($value)) { $value = self::formatArray($value); } else { $value = self::formatScalar($value); } if ($withIndexes) { $value = self::formatScalar($index) . ' => ' . $value; } }, $isAssoc); return $array; }
public function add($label, $value = '', $color = '', $highlight = '') { if (is_array($label)) { if (Arr::isAssoc($label)) { $this->data[] = $label; } else { foreach ($label as $item) { call_user_func_array([$this, 'add'], $item); } } return $this; } $this->data[] = ['label' => $label, 'value' => $value, 'color' => $color, 'highlight' => $highlight]; return $this; }
/** * Prepare input data for insert. * * @param $inserts * @return array */ public function prepareInsert($inserts) { $first = current($inserts); if (is_array($first) && Arr::isAssoc($first)) { $inserts = Arr::dot($inserts); } foreach ($inserts as $column => $value) { if (is_null($field = $this->getFieldByColumn($column))) { unset($inserts[$column]); continue; } if (method_exists($field, 'prepare')) { $inserts[$column] = $field->prepare($value); } } $prepared = []; foreach ($inserts as $key => $value) { Arr::set($prepared, $key, $value); } return $prepared; }
/** * Validate the value as safe for this object * * @param mixed $value the value to test * @return boolean */ private function isValidValue($value) { return is_scalar($value) || is_array($value) && !$this->arrHelper->isAssoc($value) && count($value) === count(array_filter($value, 'is_scalar')); }
/** * Process model relationship * * @param array $data * @param array $relationships * @param string $relationshipMethod * @return void */ protected function processRelationship(&$data, $relationships, $relationshipMethod) { if (!isset($data['relationship'])) { $data['relationship'] = []; } $relationships = Arr::isAssoc($relationships) ? [$relationships] : $relationships; foreach ($relationships as $relationship) { $method = $relationshipMethod . 'Relationship'; $data['relationship'][] = $this->grammar->{$method}($relationship); } }
/** * Structure the matches array. * * @param \Phroggyy\Discover\Contracts\Searchable $model * @param array $query * @return array|string */ private function structureMatches(Searchable $model, $query) { // If the query is an array of arrays, we assume the // developer knows exactly what they're doing and // are providing a complete match query for us. if (is_array($query) && !Arr::isAssoc($query)) { return $query; } $key = ''; // If the search index turns out to actually be nested, we // want to make sure we use the name of the subdocument // when such a query is performed. This is necessary. if ($this->indexIsNested($model->getSearchIndex())) { $key = $this->retrieveNestedIndex($model->getSearchIndex())[1] . '.'; } // If the query is just a string, we assume the user // intends to just do a simple match query on the // default search field defined in their model. if (is_string($query)) { return [['match' => [$key . $model->getDefaultSearchField() => $query]]]; } $query = Collection::make($query); return $query->map(function ($constraint, $property) use($key) { if (strpos($property, '.') === false) { $property = $key . $property; } return ['match' => [$property => $constraint]]; })->values()->all(); }
/** * Normalizes ACL presence data to an array of ACLPresence instances. * * @param $data * @return AclPresenceInterface[] */ protected function normalizeAclPresence($data) { if ($data instanceof AclPresenceInterface) { $data = [$data]; } elseif (is_array($data) && !Arr::isAssoc($data)) { $presences = []; foreach ($data as $nestedData) { $presences[] = new AclPresence($nestedData); } $data = $presences; } else { $data = [new AclPresence($data)]; } /** @var AclPresenceInterface[] $data */ // Now normalized to an array with one or more ACL presences. // Make sure the permission children are listed as simple strings. foreach ($data as $index => $presence) { $children = $presence->permissions() ?: []; if ($children instanceof Arrayable) { $children = $children->toArray(); } if (!is_array($children)) { $children = [$children]; } $data[$index]->setPermissions($children); } return $data; }
/** * Get casts from fillable attribute * When fillable is assoc the value is the type * * @return array */ protected function getCastFromFillable() { $fillable = $this->fillable; if (Arr::isAssoc($fillable)) { return $fillable; } return []; }
/** * ParseACL can be set by passing "acl" as key. This is useful specially in * mass assigments, e.g. ACL can be set alongside attributes with create(). * * @param string $key * @param mixed $value */ public function set($key, $value) { if (is_array($value)) { if (Arr::isAssoc($value)) { $this->parseObject->setAssociativeArray($key, $value); } else { $this->parseObject->setArray($key, $value); } } elseif ($value instanceof ObjectModel) { $this->parseObject->set($key, $value->parseObject); } elseif ($key == 'acl') { $this->parseObject->setACL($value); } else { $this->parseObject->set($key, $value); } return $this; }
/** * Response to get method * * @param string $path * @param array $options * @return \GuzzleHttp\Psr7\Response */ protected function get($path, $options) { list($path, $id) = static::parsePath($path); $resources = $this->collections->get($path); if (!count($resources) && ($fileStorage = $this->files->find('get', $path))) { if (!Arr::isAssoc($fileStorage)) { $fileStorage = Collection::make($fileStorage); } $this->collections->put($path, $resources = $fileStorage); } if ($id !== null) { $resources = $this->first($resources, $id); } elseif ($options['query']) { $resources = $this->filterApply($resources, $options['query']); } $status = count($resources) > 0 ? 200 : 404; return $this->createResponse($status, $resources); }
/** * Normalizes menu presence data to an array of MenuPresence instances. * * @param $data * @return MenuPresenceInterface[] */ protected function normalizeMenuPresence($data) { if ($data instanceof MenuPresenceInterface) { $data = [$data]; } elseif (is_array($data) && !Arr::isAssoc($data)) { $presences = []; foreach ($data as $nestedData) { $presences[] = new MenuPresence($nestedData); } $data = $presences; } else { $data = [new MenuPresence($data)]; } /** @var MenuPresenceInterface[] $data */ // Now normalized to an array with one or more menu presences. // Make sure the children of each menu presence are normalized aswell. foreach ($data as $index => $presence) { $children = $presence->children(); if (!empty($children)) { $data[$index]->setChildren($this->normalizeMenuPresence($children)); } } return $data; }