_id
stringlengths 2
7
| title
stringlengths 3
151
| partition
stringclasses 3
values | text
stringlengths 83
13k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q242700 | CursorBuilder.whereId | validation | protected function whereId($id, $operator)
{
/** If we are paging on the key, we only need one where clause. */
if ($this->isPagingOnKey()) {
$this->query->where($this->key, $operator, $id);
return $this;
}
$value = $this->getColumnValue($id);
$this->query->where(
$this->column, $operator . '=', $value
)->where(function ($query) use ($id, $value, $operator) {
/** @var QueryBuilder $query */
$query->where($this->column, $operator, $value)->orWhere($this->key, $operator, $id);
});
return $this;
} | php | {
"resource": ""
} |
q242701 | CursorBuilder.orderDesc | validation | protected function orderDesc()
{
$this->query->orderByDesc($this->column);
if ($this->isNotPagingOnKey()) {
$this->query->orderByDesc($this->key);
}
return $this;
} | php | {
"resource": ""
} |
q242702 | CursorBuilder.orderAsc | validation | protected function orderAsc()
{
$this->query->orderBy($this->column);
if ($this->isNotPagingOnKey()) {
$this->query->orderBy($this->key);
}
return $this;
} | php | {
"resource": ""
} |
q242703 | CursorBuilder.getColumnValue | validation | protected function getColumnValue($id)
{
$value = $this
->getQuery() // we want the raw DB value, not the Model value as that can be mutated.
->where($this->key, $id)
->value($this->column);
if (is_null($value)) {
throw new \OutOfRangeException("Cursor key {$id} does not exist or has a null value.");
}
return $value;
} | php | {
"resource": ""
} |
q242704 | CursorBuilder.guessColumn | validation | private function guessColumn()
{
if ($this->query instanceof EloquentBuilder || $this->query instanceof Relation) {
return $this->query->getModel()->getCreatedAtColumn();
}
return Model::CREATED_AT;
} | php | {
"resource": ""
} |
q242705 | CursorBuilder.guessKey | validation | private function guessKey()
{
if ($this->query instanceof EloquentBuilder || $this->query instanceof Relation) {
return $this->query->getModel()->getRouteKeyName();
}
return 'id';
} | php | {
"resource": ""
} |
q242706 | Helpers.decode | validation | public static function decode($content, $assoc = false, $depth = 512, $options = 0)
{
$decoded = \json_decode($content, $assoc, $depth, $options);
if (JSON_ERROR_NONE !== json_last_error()) {
throw InvalidJsonException::create();
}
if (!$assoc && !is_object($decoded)) {
throw new DocumentRequiredException();
}
if ($assoc && !is_array($decoded)) {
throw new InvalidJsonException(null, 'JSON is not an array.');
}
return $decoded;
} | php | {
"resource": ""
} |
q242707 | Helpers.doesRequestHaveBody | validation | public static function doesRequestHaveBody($request)
{
if (self::hasHeader($request, 'Transfer-Encoding')) {
return true;
};
if (1 > self::getHeader($request, 'Content-Length')) {
return false;
}
return true;
} | php | {
"resource": ""
} |
q242708 | Helpers.doesResponseHaveBody | validation | public static function doesResponseHaveBody($request, $response)
{
if ('HEAD' === strtoupper($request->getMethod())) {
return false;
}
$status = $response->getStatusCode();
if ((100 <= $status && 200 > $status) || 204 === $status || 304 === $status) {
return false;
}
if (self::hasHeader($response, 'Transfer-Encoding')) {
return true;
};
if (!$contentLength = self::getHeader($response, 'Content-Length')) {
return false;
}
return 0 < $contentLength[0];
} | php | {
"resource": ""
} |
q242709 | Helpers.wantsJsonApi | validation | public static function wantsJsonApi($request)
{
$acceptable = $request->getAcceptableContentTypes();
return isset($acceptable[0]) && IlluminateStr::contains($acceptable[0], MediaType::JSON_API_SUB_TYPE);
} | php | {
"resource": ""
} |
q242710 | Helpers.httpErrorStatus | validation | public static function httpErrorStatus($errors, int $default = SymfonyResponse::HTTP_BAD_REQUEST): int
{
if ($errors instanceof ErrorInterface) {
$errors = [$errors];
}
$statuses = collect($errors)->reject(function (ErrorInterface $error) {
return is_null($error->getStatus());
})->map(function (ErrorInterface $error) {
return (int) $error->getStatus();
})->unique();
if (2 > count($statuses)) {
return $statuses->first() ?: $default;
}
$only4xx = $statuses->every(function (int $status) {
return 400 <= $status && 499 >= $status;
});
return $only4xx ? SymfonyResponse::HTTP_BAD_REQUEST : SymfonyResponse::HTTP_INTERNAL_SERVER_ERROR;
} | php | {
"resource": ""
} |
q242711 | Factory.createResolver | validation | public function createResolver($apiName, array $config)
{
$factoryName = isset($config['resolver']) ? $config['resolver'] : ResolverFactory::class;
$factory = $this->container->make($factoryName);
if ($factory instanceof ResolverInterface) {
return $factory;
}
if (!is_callable($factory)) {
throw new RuntimeException("Factory {$factoryName} cannot be invoked.");
}
$resolver = $factory($apiName, $config);
if (!$resolver instanceof ResolverInterface) {
throw new RuntimeException("Factory {$factoryName} did not create a resolver instance.");
}
return $resolver;
} | php | {
"resource": ""
} |
q242712 | Factory.createResponseFactory | validation | public function createResponseFactory(Api $api)
{
return new Responses(
$this,
$api,
$this->container->make(Route::class),
$this->container->make('json-api.exceptions')
);
} | php | {
"resource": ""
} |
q242713 | Factory.createRelationshipDocumentValidator | validation | public function createRelationshipDocumentValidator($document)
{
return new Validation\Spec\RelationValidator(
$this->container->make(StoreInterface::class),
$this->createErrorTranslator(),
$document
);
} | php | {
"resource": ""
} |
q242714 | Factory.createValidator | validation | public function createValidator(
array $data,
array $rules,
array $messages = [],
array $customAttributes = [],
\Closure $callback = null
): ValidatorInterface
{
$translator = $this->createErrorTranslator();
return new Validation\Validator(
$this->makeValidator($data, $rules, $messages, $customAttributes),
$translator,
$callback
);
} | php | {
"resource": ""
} |
q242715 | Factory.createResourceValidator | validation | public function createResourceValidator(
ResourceObject $resource,
array $rules,
array $messages = [],
array $customAttributes = []
) {
return $this->createValidator(
$resource->all(),
$rules,
$messages,
$customAttributes,
function ($key, $detail, $failed) use ($resource) {
return $this->invalidResource(
$resource->pointer($key, '/data'),
$detail,
$failed
);
}
);
} | php | {
"resource": ""
} |
q242716 | Factory.createRelationshipValidator | validation | public function createRelationshipValidator(
ResourceObject $resource,
array $rules,
array $messages = [],
array $customAttributes = []
) {
return $this->createValidator(
$resource->all(),
$rules,
$messages,
$customAttributes,
function ($key, $detail, $failed) use ($resource) {
return $this->invalidResource(
$resource->pointerForRelationship($key, '/data'),
$detail,
$failed
);
}
);
} | php | {
"resource": ""
} |
q242717 | Factory.createQueryValidator | validation | public function createQueryValidator(
array $data,
array $rules,
array $messages = [],
array $customAttributes = []
) {
return $this->createValidator(
$data,
$rules,
$messages,
$customAttributes,
function ($key, $detail, $failed) {
return $this->invalidQueryParameter($key, $detail, $failed);
}
);
} | php | {
"resource": ""
} |
q242718 | UrlGenerator.update | validation | public function update($resourceType, $id, array $queryParams = [])
{
return $this->resource(RouteName::update($resourceType), $id, $queryParams);
} | php | {
"resource": ""
} |
q242719 | UrlGenerator.delete | validation | public function delete($resourceType, $id, array $queryParams = [])
{
return $this->resource(RouteName::delete($resourceType), $id, $queryParams);
} | php | {
"resource": ""
} |
q242720 | UrlGenerator.removeRelationship | validation | public function removeRelationship($resourceType, $id, $relationshipKey, array $queryParams = [])
{
$name = RouteName::removeRelationship($resourceType, $relationshipKey);
return $this->resource($name, $id, $queryParams);
} | php | {
"resource": ""
} |
q242721 | AbstractResolver.flip | validation | private function flip(array $resources)
{
$all = [];
foreach ($resources as $resourceType => $types) {
foreach ((array) $types as $type) {
$all[$type] = $resourceType;
}
}
return $all;
} | php | {
"resource": ""
} |
q242722 | Api.getDefaultCodec | validation | public function getDefaultCodec(): Codec
{
return $this->factory->createCodec(
$this->getContainer(),
$this->encodings->find(MediaTypeInterface::JSON_API_MEDIA_TYPE) ?: Encoding::jsonApi(),
$this->decodings->find(MediaTypeInterface::JSON_API_MEDIA_TYPE)
);
} | php | {
"resource": ""
} |
q242723 | Api.encoder | validation | public function encoder($options = 0, $depth = 512)
{
if ($options instanceof Encoding) {
$options = $options->getOptions();
}
if (!$options instanceof EncoderOptions) {
$options = new EncoderOptions($options, $this->getUrl()->toString(), $depth);
}
return $this->factory->createEncoder($this->getContainer(), $options);
} | php | {
"resource": ""
} |
q242724 | Api.register | validation | public function register(AbstractProvider $provider)
{
$this->resolver->attach($provider->getResolver());
$this->errors = array_replace($provider->getErrors(), $this->errors);
} | php | {
"resource": ""
} |
q242725 | Decoding.create | validation | public static function create($mediaType, $decoder): self
{
if (is_string($mediaType)) {
$mediaType = MediaType::parse(0, $mediaType);
}
if (!$mediaType instanceof MediaTypeInterface) {
throw new \InvalidArgumentException('Expecting a media type object or string.');
}
if (is_string($decoder)) {
$decoder = app($decoder);
}
if (!$decoder instanceof DecoderInterface) {
throw new \InvalidArgumentException('Expecting a decoder or decoder service name.');
}
return new self($mediaType, $decoder);
} | php | {
"resource": ""
} |
q242726 | DecodingList.prepend | validation | public function prepend(Decoding ...$decodings): self
{
$copy = clone $this;
array_unshift($copy->stack, ...$decodings);
return $copy;
} | php | {
"resource": ""
} |
q242727 | DecodingList.push | validation | public function push(Decoding ...$decodings): self
{
$copy = new self();
$copy->stack = collect($this->stack)->merge($decodings)->all();
return $copy;
} | php | {
"resource": ""
} |
q242728 | DecodingList.merge | validation | public function merge(DecodingList $decodings): self
{
$copy = new self();
$copy->stack = collect($this->stack)->merge($decodings->stack)->all();
return $copy;
} | php | {
"resource": ""
} |
q242729 | DecodingList.when | validation | public function when(bool $test, $decodings): self
{
if (!$test) {
return $this;
}
if ($decodings instanceof \Closure) {
return $decodings($this);
}
$decodings = $decodings instanceof Decoding ? [$decodings] : $decodings;
return $this->push(...$decodings);
} | php | {
"resource": ""
} |
q242730 | DecodingList.unless | validation | public function unless(bool $test, $decodings): self
{
return $this->when(true !== $test, $decodings);
} | php | {
"resource": ""
} |
q242731 | DecodingList.equalsTo | validation | public function equalsTo(MediaTypeInterface $mediaType): ?Decoding
{
return collect($this->stack)->first(function (Decoding $decoding) use ($mediaType) {
return $decoding->equalsTo($mediaType);
});
} | php | {
"resource": ""
} |
q242732 | Arr.camelize | validation | public static function camelize($data)
{
return collect($data)->mapWithKeys(function ($value, $key) {
$key = Str::camelize($key);
if (is_array($value)) {
return [$key => static::camelize($value)];
}
return [$key => $value];
})->all();
} | php | {
"resource": ""
} |
q242733 | LinkGenerator.current | validation | public function current($meta = null, array $queryParams = [])
{
$url = $this->generator->current();
if ($queryParams) {
$url .= '?' . http_build_query($queryParams);
}
return $this->factory->createLink($url, $meta, true);
} | php | {
"resource": ""
} |
q242734 | LinkGenerator.index | validation | public function index($resourceType, $meta = null, array $queryParams = [])
{
return $this->factory->createLink(
$this->urls->index($resourceType, $queryParams),
$meta,
true
);
} | php | {
"resource": ""
} |
q242735 | EncodingList.fromArray | validation | public static function fromArray(iterable $config, string $urlPrefix = null): self
{
return new self(
...collect($config)->map(function ($value, $key) use ($urlPrefix) {
return Encoding::fromArray($key, $value, $urlPrefix);
})->values()
);
} | php | {
"resource": ""
} |
q242736 | EncodingList.createCustom | validation | public static function createCustom(...$mediaTypes): self
{
$encodings = new self();
$encodings->stack = collect($mediaTypes)->map(function ($mediaType) {
return Encoding::custom($mediaType);
})->all();
return $encodings;
} | php | {
"resource": ""
} |
q242737 | EncodingList.prepend | validation | public function prepend(Encoding ...$encodings): self
{
$copy = clone $this;
array_unshift($copy->stack, ...$encodings);
return $copy;
} | php | {
"resource": ""
} |
q242738 | EncodingList.push | validation | public function push(Encoding ...$encodings): self
{
$copy = new self();
$copy->stack = collect($this->stack)->merge($encodings)->all();
return $copy;
} | php | {
"resource": ""
} |
q242739 | EncodingList.merge | validation | public function merge(EncodingList $encodings): self
{
$copy = new self();
$copy->stack = collect($this->stack)->merge($encodings->stack)->all();
return $copy;
} | php | {
"resource": ""
} |
q242740 | EncodingList.when | validation | public function when(bool $test, $encodings): self
{
if (!$test || is_null($encodings)) {
return $this;
}
if ($encodings instanceof \Closure) {
return $encodings($this);
}
if (is_string($encodings)) {
$encodings = Encoding::custom($encodings);
}
$encodings = $encodings instanceof Encoding ? [$encodings] : $encodings;
return $this->push(...$encodings);
} | php | {
"resource": ""
} |
q242741 | EncodingList.unless | validation | public function unless(bool $test, $encodings): self
{
return $this->when(true !== $test, $encodings);
} | php | {
"resource": ""
} |
q242742 | EncodingList.matchesTo | validation | public function matchesTo(MediaTypeInterface $mediaType): ?Encoding
{
return collect($this->stack)->first(function (Encoding $encoding) use ($mediaType) {
return $encoding->matchesTo($mediaType);
});
} | php | {
"resource": ""
} |
q242743 | EncodingList.acceptable | validation | public function acceptable(AcceptHeaderInterface $accept): ?Encoding
{
foreach ($accept->getMediaTypes() as $mediaType) {
if ($encoding = $this->matchesTo($mediaType)) {
return $encoding;
}
}
return null;
} | php | {
"resource": ""
} |
q242744 | BootJsonApi.handle | validation | public function handle($request, Closure $next, string $namespace)
{
/** Build and register the API. */
$api = $this->bindApi($namespace, $request->getSchemeAndHttpHost() . $request->getBaseUrl());
/** Substitute route bindings. */
$this->substituteBindings($api);
/** Set up the Laravel paginator to read from JSON API request instead */
$this->bindPageResolver();
return $next($request);
} | php | {
"resource": ""
} |
q242745 | BootJsonApi.bindApi | validation | protected function bindApi(string $namespace, string $host): Api
{
/** @var Repository $repository */
$repository = $this->container->make(Repository::class);
$api = $repository->createApi($namespace, $host);
$this->container->instance(Api::class, $api);
$this->container->alias(Api::class, 'json-api.inbound');
return $api;
} | php | {
"resource": ""
} |
q242746 | BootJsonApi.bindPageResolver | validation | protected function bindPageResolver(): void
{
/** Override the current page resolution */
AbstractPaginator::currentPageResolver(function ($pageName) {
$pagination = app(EncodingParametersInterface::class)->getPaginationParameters() ?: [];
return $pagination[$pageName] ?? null;
});
} | php | {
"resource": ""
} |
q242747 | CreatesPages.buildParams | validation | protected function buildParams(EncodingParametersInterface $parameters)
{
return array_filter([
QueryParametersParserInterface::PARAM_FILTER =>
$parameters->getFilteringParameters(),
QueryParametersParserInterface::PARAM_SORT =>
$this->buildSortParams((array) $parameters->getSortParameters())
]);
} | php | {
"resource": ""
} |
q242748 | ClientDispatchable.didCreate | validation | public function didCreate($resource): void
{
if ($this->wasClientDispatched()) {
$this->clientJob->setResource($resource)->save();
}
} | php | {
"resource": ""
} |
q242749 | Url.fromArray | validation | public static function fromArray(array $url): self
{
return new self(
isset($url['host']) ? $url['host'] : '',
isset($url['namespace']) ? $url['namespace'] : '',
isset($url['name']) ? $url['name'] : ''
);
} | php | {
"resource": ""
} |
q242750 | Url.getResourceUrl | validation | public function getResourceUrl(string $type, $id, array $params = []): string
{
return $this->url([$type, $id], $params);
} | php | {
"resource": ""
} |
q242751 | Url.getRelatedUrl | validation | public function getRelatedUrl(string $type, $id, string $field, array $params = []): string
{
return $this->url([$type, $id, $field], $params);
} | php | {
"resource": ""
} |
q242752 | Url.getRelationshipUri | validation | public function getRelationshipUri(string $type, $id, string $field, array $params = []): string
{
return $this->url([$type, $id, 'relationships', $field], $params);
} | php | {
"resource": ""
} |
q242753 | JsonApiController.read | validation | public function read(StoreInterface $store, FetchResource $request)
{
$result = $this->doRead($store, $request);
if ($this->isResponse($result)) {
return $result;
}
return $this->reply()->content($result);
} | php | {
"resource": ""
} |
q242754 | JsonApiController.create | validation | public function create(StoreInterface $store, CreateResource $request)
{
$record = $this->transaction(function () use ($store, $request) {
return $this->doCreate($store, $request);
});
if ($this->isResponse($record)) {
return $record;
}
return $this->reply()->created($record);
} | php | {
"resource": ""
} |
q242755 | JsonApiController.update | validation | public function update(StoreInterface $store, UpdateResource $request)
{
$record = $this->transaction(function () use ($store, $request) {
return $this->doUpdate($store, $request);
});
if ($this->isResponse($record)) {
return $record;
}
return $this->reply()->updated($record);
} | php | {
"resource": ""
} |
q242756 | JsonApiController.delete | validation | public function delete(StoreInterface $store, DeleteResource $request)
{
$result = $this->transaction(function () use ($store, $request) {
return $this->doDelete($store, $request);
});
if ($this->isResponse($result)) {
return $result;
}
return $this->reply()->deleted($result);
} | php | {
"resource": ""
} |
q242757 | JsonApiController.readRelatedResource | validation | public function readRelatedResource(StoreInterface $store, FetchRelated $request)
{
$record = $request->getRecord();
$result = $this->beforeReadingRelationship($record, $request);
if ($this->isResponse($result)) {
return $result;
}
$related = $store->queryRelated(
$record,
$request->getRelationshipName(),
$request->getParameters()
);
$records = ($related instanceof PageInterface) ? $related->getData() : $related;
$result = $this->afterReadingRelationship($record, $records, $request);
if ($this->isInvokedResult($result)) {
return $result;
}
return $this->reply()->content($related);
} | php | {
"resource": ""
} |
q242758 | JsonApiController.readRelationship | validation | public function readRelationship(StoreInterface $store, FetchRelationship $request)
{
$record = $request->getRecord();
$result = $this->beforeReadingRelationship($record, $request);
if ($this->isResponse($result)) {
return $result;
}
$related = $store->queryRelationship(
$record,
$request->getRelationshipName(),
$request->getParameters()
);
$records = ($related instanceof PageInterface) ? $related->getData() : $related;
$result = $this->afterReadingRelationship($record, $records, $request);
if ($this->isInvokedResult($result)) {
return $result;
}
return $this->reply()->relationship($related);
} | php | {
"resource": ""
} |
q242759 | JsonApiController.replaceRelationship | validation | public function replaceRelationship(StoreInterface $store, UpdateRelationship $request)
{
$result = $this->transaction(function () use ($store, $request) {
return $this->doReplaceRelationship($store, $request);
});
if ($this->isResponse($result)) {
return $result;
}
return $this->reply()->noContent();
} | php | {
"resource": ""
} |
q242760 | JsonApiController.addToRelationship | validation | public function addToRelationship(StoreInterface $store, UpdateRelationship $request)
{
$result = $this->transaction(function () use ($store, $request) {
return $this->doAddToRelationship($store, $request);
});
if ($this->isResponse($result)) {
return $result;
}
return $this->reply()->noContent();
} | php | {
"resource": ""
} |
q242761 | JsonApiController.removeFromRelationship | validation | public function removeFromRelationship(StoreInterface $store, UpdateRelationship $request)
{
$result = $this->transaction(function () use ($store, $request) {
return $this->doRemoveFromRelationship($store, $request);
});
if ($this->isResponse($result)) {
return $result;
}
return $this->reply()->noContent();
} | php | {
"resource": ""
} |
q242762 | JsonApiController.processes | validation | public function processes(StoreInterface $store, FetchProcesses $request)
{
$result = $store->queryRecords(
$request->getProcessType(),
$request->getEncodingParameters()
);
return $this->reply()->content($result);
} | php | {
"resource": ""
} |
q242763 | JsonApiController.process | validation | public function process(StoreInterface $store, FetchProcess $request)
{
$record = $store->readRecord(
$request->getProcess(),
$request->getEncodingParameters()
);
return $this->reply()->process($record);
} | php | {
"resource": ""
} |
q242764 | JsonApiController.doSearch | validation | protected function doSearch(StoreInterface $store, FetchResources $request)
{
if ($result = $this->invoke('searching', $request)) {
return $result;
}
$found = $store->queryRecords($request->getResourceType(), $request->getParameters());
$records = ($found instanceof PageInterface) ? $found->getData() : $found;
if ($result = $this->invoke('searched', $records, $request)) {
return $result;
}
return $found;
} | php | {
"resource": ""
} |
q242765 | JsonApiController.doRead | validation | protected function doRead(StoreInterface $store, FetchResource $request)
{
$record = $request->getRecord();
if ($result = $this->invoke('reading', $record, $request)) {
return $result;
}
/** We pass to the store for filtering, eager loading etc. */
$record = $store->readRecord($record, $request->getParameters());
if ($result = $this->invoke('didRead', $record, $request)) {
return $result;
}
return $record;
} | php | {
"resource": ""
} |
q242766 | JsonApiController.doCreate | validation | protected function doCreate(StoreInterface $store, CreateResource $request)
{
if ($response = $this->beforeCommit($request)) {
return $response;
}
$record = $store->createRecord(
$request->getResourceType(),
$request->all(),
$request->getParameters()
);
return $this->afterCommit($request, $record, false) ?: $record;
} | php | {
"resource": ""
} |
q242767 | JsonApiController.doUpdate | validation | protected function doUpdate(StoreInterface $store, UpdateResource $request)
{
if ($response = $this->beforeCommit($request)) {
return $response;
}
$record = $store->updateRecord(
$request->getRecord(),
$request->all(),
$request->getParameters()
);
return $this->afterCommit($request, $record, true) ?: $record;
} | php | {
"resource": ""
} |
q242768 | JsonApiController.doReplaceRelationship | validation | protected function doReplaceRelationship(StoreInterface $store, UpdateRelationship $request)
{
$record = $request->getRecord();
$name = Str::classify($field = $request->getRelationshipName());
if ($result = $this->invokeMany(['replacing', "replacing{$name}"], $record, $request)) {
return $result;
}
$record = $store->replaceRelationship(
$record,
$field,
$request->all(),
$request->getParameters()
);
return $this->invokeMany(["replaced{$name}", "replaced"], $record, $request) ?: $record;
} | php | {
"resource": ""
} |
q242769 | JsonApiController.transaction | validation | protected function transaction(Closure $closure)
{
if (!$this->useTransactions) {
return $closure();
}
return app('db')->connection($this->connection)->transaction($closure);
} | php | {
"resource": ""
} |
q242770 | RouteRegistrar.route | validation | public function route(): RouteRegistration
{
$route = new RouteRegistration($this->router, $this, $this->defaults);
$route->controller($this->options['controller'] ?? '');
return $route;
} | php | {
"resource": ""
} |
q242771 | RouteRegistrar.resource | validation | public function resource(string $resourceType, array $options = []): ResourceRegistration
{
return new ResourceRegistration(
$this->router,
$resourceType,
array_merge($this->options, $options)
);
} | php | {
"resource": ""
} |
q242772 | ValidationException.create | validation | public static function create(ValidatorInterface $validator): self
{
$ex = new self($validator->getErrors());
$ex->validator = $validator;
return $ex;
} | php | {
"resource": ""
} |
q242773 | AbstractResourceAdapter.deserialize | validation | protected function deserialize(array $document, $record = null): ResourceObject
{
$data = $document['data'] ?? [];
if (!is_array($data) || empty($data)) {
throw new \InvalidArgumentException('Expecting a JSON API document with a data member.');
}
return ResourceObject::create($data);
} | php | {
"resource": ""
} |
q242774 | AbstractResourceAdapter.isFillableRelation | validation | protected function isFillableRelation($field, $record)
{
return $this->isRelation($field) && $this->isFillable($field, $record);
} | php | {
"resource": ""
} |
q242775 | AbstractResourceAdapter.methodForRelation | validation | protected function methodForRelation($field)
{
if (method_exists($this, $field)) {
return $field;
}
$method = Str::camelize($field);
return method_exists($this, $method) ? $method : null;
} | php | {
"resource": ""
} |
q242776 | AbstractResourceAdapter.fill | validation | protected function fill($record, ResourceObject $resource, EncodingParametersInterface $parameters)
{
$this->fillAttributes($record, $resource->getAttributes());
$this->fillRelationships($record, $resource->getRelationships(), $parameters);
} | php | {
"resource": ""
} |
q242777 | AbstractResourceAdapter.fillRelationships | validation | protected function fillRelationships(
$record,
Collection $relationships,
EncodingParametersInterface $parameters
) {
$relationships->filter(function ($value, $field) use ($record) {
return $this->isFillableRelation($field, $record);
})->each(function ($value, $field) use ($record, $parameters) {
$this->fillRelationship($record, $field, $value, $parameters);
});
} | php | {
"resource": ""
} |
q242778 | AbstractResourceAdapter.fillRelationship | validation | protected function fillRelationship(
$record,
$field,
array $relationship,
EncodingParametersInterface $parameters
) {
$relation = $this->getRelated($field);
$relation->update($record, $relationship, $parameters);
} | php | {
"resource": ""
} |
q242779 | NegotiateContent.willSeeOne | validation | public function willSeeOne($request): bool
{
if ($this->route->isRelationship()) {
return false;
}
if ($this->route->isResource()) {
return true;
}
return $request->isMethod('POST');
} | php | {
"resource": ""
} |
q242780 | NegotiateContent.isExpectingContent | validation | protected function isExpectingContent($request): bool
{
$methods = $this->route->isNotRelationship() ? ['POST', 'PATCH'] : ['POST', 'PATCH', 'DELETE'];
return \in_array($request->getMethod(), $methods);
} | php | {
"resource": ""
} |
q242781 | CursorStrategy.withQualifiedColumn | validation | public function withQualifiedColumn($column)
{
$parts = explode('.', $column);
if (!isset($parts[1])) {
throw new \InvalidArgumentException('Expecting a valid qualified column name.');
}
$this->withColumn($parts[1]);
return $this;
} | php | {
"resource": ""
} |
q242782 | CursorStrategy.withQualifiedKeyName | validation | public function withQualifiedKeyName($keyName)
{
$parts = explode('.', $keyName);
if (!isset($parts[1])) {
throw new \InvalidArgumentException('Expecting a valid qualified column name.');
}
$this->withIdentifierColumn($parts[1]);
return $this;
} | php | {
"resource": ""
} |
q242783 | CursorStrategy.query | validation | protected function query($query)
{
return new CursorBuilder(
$query,
$this->column,
$this->identifier,
$this->descending
);
} | php | {
"resource": ""
} |
q242784 | CursorStrategy.cursor | validation | protected function cursor(EncodingParametersInterface $parameters)
{
return Cursor::create(
(array) $parameters->getPaginationParameters(),
$this->before,
$this->after,
$this->limit
);
} | php | {
"resource": ""
} |
q242785 | Codec.encodes | validation | public function encodes(string ...$mediaTypes): bool
{
$encoding = $this->getEncodingMediaType();
return collect($mediaTypes)->contains(function ($mediaType, $index) use ($encoding) {
return $encoding->equalsTo(MediaType::parse($index, $mediaType));
});
} | php | {
"resource": ""
} |
q242786 | Codec.decodes | validation | public function decodes(string ...$mediaTypes): bool
{
if (!$decoding = $this->getDecodingMediaType()) {
return false;
}
return collect($mediaTypes)->contains(function ($mediaType, $index) use ($decoding) {
return $decoding->equalsTo(MediaType::parse($index, $mediaType));
});
} | php | {
"resource": ""
} |
q242787 | Codec.document | validation | public function document($request): ?\stdClass
{
if ($this->cannotDecodeJsonApi()) {
return null;
}
return $this->decoding->getJsonApiDecoder()->document($request);
} | php | {
"resource": ""
} |
q242788 | ResourceRegistrar.registerCustom | validation | public function registerCustom(): void
{
if (!$fn = $this->group) {
return;
}
$this->router->group([], function () use ($fn) {
$fn(new RouteRegistrar(
$this->router,
['controller' => $this->controller()],
[self::PARAM_RESOURCE_TYPE => $this->resourceType]
));
});
} | php | {
"resource": ""
} |
q242789 | ResourceRegistrar.registerProcesses | validation | private function registerProcesses(): void
{
$this->routeForProcess(
'get',
$this->baseProcessUrl(),
$this->actionForRoute('processes')
);
$this->routeForProcess(
'get',
$this->processUrl(),
$this->actionForRoute('process')
);
} | php | {
"resource": ""
} |
q242790 | Authorize.authorizeRelationship | validation | protected function authorizeRelationship(AuthorizerInterface $authorizer, $request, $record, string $field): void
{
if ($this->isModifyRelationship($request)) {
$authorizer->modifyRelationship($record, $field, $request);
return;
}
$authorizer->readRelationship($record, $field, $request);
} | php | {
"resource": ""
} |
q242791 | QueriesRelations.getRelation | validation | protected function getRelation($record, $key)
{
$relation = $record->{$key}();
if (!$relation || !$this->acceptRelation($relation)) {
throw new RuntimeException(sprintf(
'JSON API relation %s cannot be used for an Eloquent %s relation.',
class_basename($this),
class_basename($relation)
));
}
return $relation;
} | php | {
"resource": ""
} |
q242792 | QueriesRelations.requiresInverseAdapter | validation | protected function requiresInverseAdapter($record, EncodingParametersInterface $parameters)
{
return !empty($parameters->getFilteringParameters()) ||
!empty($parameters->getSortParameters()) ||
!empty($parameters->getPaginationParameters()) ||
!empty($parameters->getIncludePaths());
} | php | {
"resource": ""
} |
q242793 | QueriesRelations.adapterFor | validation | protected function adapterFor($relation)
{
$adapter = $this->getStore()->adapterFor($relation->getModel());
if (!$adapter instanceof AbstractAdapter) {
throw new RuntimeException('Expecting inverse resource adapter to be an Eloquent adapter.');
}
return $adapter;
} | php | {
"resource": ""
} |
q242794 | AbstractValidatorProvider.resourceAttributes | validation | protected function resourceAttributes($record = null)
{
return $this->validatorFactory()->attributes(
$this->attributeRules($record),
$this->attributeMessages($record),
$this->attributeCustomAttributes($record),
function (Validator $validator) use ($record) {
return $this->conditionalAttributes($validator, $record);
},
function (ResourceObjectInterface $resource, $record) {
return $this->extractAttributes($resource, $record);
}
);
} | php | {
"resource": ""
} |
q242795 | AbstractValidatorProvider.resourceRelationships | validation | protected function resourceRelationships($record = null)
{
$validator = $this->validatorFactory()->relationships();
$this->relationshipRules($validator, $record);
return $validator;
} | php | {
"resource": ""
} |
q242796 | AbstractValidatorProvider.queryValidatorWithoutSearch | validation | protected function queryValidatorWithoutSearch()
{
return $this->validatorFactory()->queryParameters(
$this->queryRulesWithoutSearch(),
$this->queryMessages(),
$this->queryCustomAttributes(),
function (Validator $validator) {
return $this->conditionalQuery($validator);
}
);
} | php | {
"resource": ""
} |
q242797 | AbstractValidatorProvider.queryRulesWithoutSearch | validation | protected function queryRulesWithoutSearch()
{
return collect($this->queryRules())->reject(function ($value, $key) {
return Str::startsWith($key, ['filter.', 'sort.', 'page.']);
})->all();
} | php | {
"resource": ""
} |
q242798 | StandardStrategy.defaultOrder | validation | protected function defaultOrder($query)
{
if ($this->doesRequireOrdering($query)) {
$query->orderBy($this->primaryKey);
}
return $this;
} | php | {
"resource": ""
} |
q242799 | StandardStrategy.doesRequireOrdering | validation | protected function doesRequireOrdering($query)
{
if (!$this->primaryKey) {
return false;
}
$query = ($query instanceof Relation) ? $query->getBaseQuery() : $query->getQuery();
return !collect($query->orders ?: [])->contains(function (array $order) {
$col = $order['column'] ?? '';
return $this->primaryKey === $col;
});
} | php | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.