Oihana PHP System

ExistModelRule extends ContainerRule

Rule: Checks if a given value exists in a model retrieved from a DI container.

This rule validates that a specific value is present in a model implementing the ExistModel interface. The model is retrieved from a PSR-11 compatible container, allowing dynamic resolution of dependencies.

Usage

use DI\Container;
use oihana\validations\rules\models\ExistModelRule;
use tests\oihana\models\mocks\MockDocumentsModel;

$model = new MockDocumentsModel();
$model->addDocument(['id' => 1, 'name' => 'John']);

$container = new Container();
$container->set('model', $model);

$rule = new ExistModelRule($container, ['model' => 'model']);
$rule->check(1);       // true
$rule->check('Alice'); // false

// With custom key
$rule = new ExistModelRule($container, ['model' => 'model', 'key' => 'name']);
$rule->check('John');  // true
$rule->check('Alice'); // false

Constructor Parameters

  • ContainerInterface $container : PSR-11 container reference
  • string|array $init : Model identifier or array of initialization parameters
  • ?string $key : Optional key to use if $init is a string

Options

The rule accepts the following keys in $init:

  • ExistModelRule::MODEL : The container identifier of the model
  • ExistModelRule::KEY : The key in the model to check against (default: Schema::ID)

Exceptions

Throws ParameterException if required parameters (MODEL or KEY) are missing. Throws ContainerExceptionInterface or NotFoundExceptionInterface if container access fails.

Tags
see
ExistModel

The interface that the model must implement to support existence checking

see
ContainerRule

The abstract base class providing container access

author

Marc Alcaraz

since
1.0.0

Table of Contents

Constants

DEFAULT_KEY  = \org\schema\constants\Schema::ID
The default 'key' value.
KEY  = 'key'
The 'key' parameter key.
LOGGABLE  = 'loggable'
The 'loggable' parameter constant.
LOGGER  = 'logger'
The 'logger' parameter constant.
MODEL  = 'model'
The 'model' parameter key.

Properties

$loggable  : bool
The loggable flag.
$container  : ContainerInterface
The DI container reference.
$fillableParams  : array<string|int, mixed>
The internal list of fillable parameters.
$message  : string
The internal message pattern.

Methods

__construct()  : mixed
Creates a new ExistModelRule instance.
__toString()  : string
Returns a String representation of the object.
alert()  : void
Action must be taken immediately.
check()  : bool
Checks whether the given value satisfies the condition.
critical()  : void
Critical conditions.
debug()  : void
Detailed debug information.
emergency()  : void
System is unusable.
error()  : void
Runtime errors that do not require immediate action but should typically be logged and monitored.
getLogger()  : LoggerInterface|null
Returns the logger reference.
info()  : void
Interesting events.
initializeLoggable()  : static
Initialize the loggable flag.
initializeLogger()  : static
Initializes the logger reference for the current instance.
key()  : $this
Defines the optional key to find the ressource in the model.
log()  : void
Logs with an arbitrary level.
model()  : $this
Defines the model identifier to find it in the DI container.
notice()  : void
Normal but significant events.
warning()  : void
Exceptional occurrences that are not errors.

Constants

DEFAULT_KEY

The default 'key' value.

public mixed DEFAULT_KEY = \org\schema\constants\Schema::ID

LOGGABLE

The 'loggable' parameter constant.

public mixed LOGGABLE = 'loggable'

LOGGER

The 'logger' parameter constant.

public mixed LOGGER = 'logger'

Properties

$loggable

The loggable flag.

public bool $loggable = false

$container

The DI container reference.

protected ContainerInterface $container

$fillableParams

The internal list of fillable parameters.

protected array<string|int, mixed> $fillableParams = [self::MODEL, self::KEY]

$message

The internal message pattern.

protected string $message = ":attribute is not registered in the model ':model' with the value ':value'"

Methods

__construct()

Creates a new ExistModelRule instance.

public __construct(ContainerInterface $container[, array<string|int, mixed>|string $init = [] ][, string|null $key = null ]) : mixed
Parameters
$container : ContainerInterface

The DI container reference.

$init : array<string|int, mixed>|string = []

The options to passed-in the rule.

$key : string|null = null
Tags
throws
ContainerExceptionInterface
throws
NotFoundExceptionInterface

__toString()

Returns a String representation of the object.

public __toString() : string
Tags
throws
ReflectionException
Return values
string

A string representation of the object.

alert()

Action must be taken immediately.

public alert(string|Stringable $message[, array<string|int, mixed> $context = [] ]) : void

Example: Entire website down, database unavailable, etc. This should trigger the SMS alerts and wake you up.

Parameters
$message : string|Stringable
$context : array<string|int, mixed> = []

check()

Checks whether the given value satisfies the condition.

public check(mixed $value) : bool
Parameters
$value : mixed

The value to check.

Tags
throws
ContainerExceptionInterface
throws
NotFoundExceptionInterface
throws
ParameterException
Return values
bool

True if the value satisfies the condition.

critical()

Critical conditions.

public critical(string|Stringable $message[, array<string|int, mixed> $context = [] ]) : void

Example: Application component unavailable, unexpected exception.

Parameters
$message : string|Stringable
$context : array<string|int, mixed> = []

debug()

Detailed debug information.

public debug(string|Stringable $message[, array<string|int, mixed> $context = [] ]) : void
Parameters
$message : string|Stringable
$context : array<string|int, mixed> = []

emergency()

System is unusable.

public emergency(string|Stringable $message[, array<string|int, mixed> $context = [] ]) : void
Parameters
$message : string|Stringable
$context : array<string|int, mixed> = []

error()

Runtime errors that do not require immediate action but should typically be logged and monitored.

public error(string|Stringable $message[, array<string|int, mixed> $context = [] ]) : void
Parameters
$message : string|Stringable
$context : array<string|int, mixed> = []

getLogger()

Returns the logger reference.

public getLogger() : LoggerInterface|null
Return values
LoggerInterface|null

info()

Interesting events.

public info(string|Stringable $message[, array<string|int, mixed> $context = [] ]) : void

Example: User logs in, SQL logs.

Parameters
$message : string|Stringable
$context : array<string|int, mixed> = []

initializeLoggable()

Initialize the loggable flag.

public initializeLoggable([bool|array<string|int, mixed>|null $init = null ][, ContainerInterface|null $container = null ][, bool|array<string|int, mixed>|null $defaultValue = false ]) : static
Parameters
$init : bool|array<string|int, mixed>|null = null

The definition to initialize the loggable property.

$container : ContainerInterface|null = null
$defaultValue : bool|array<string|int, mixed>|null = false

The default value if the $init argument is not defined.

Tags
throws
ContainerExceptionInterface
throws
NotFoundExceptionInterface
Return values
static

initializeLogger()

Initializes the logger reference for the current instance.

public initializeLogger([array<string|int, mixed>|LoggerInterface|string|null $init = null ][, ContainerInterface|null $container = null ][, bool $useDefault = true ]) : static

This method accepts either:

  • A LoggerInterface instance
  • An associative array containing a logger reference under the static::LOGGER key
  • A string representing a service ID or class name resolvable by the container
  • null or an empty value, which will default to LoggerInterface::class depending on the $useDefault parameter.

If a dependency injection container is provided, the method will attempt to resolve the logger service from it. If no valid logger can be resolved, the $this->logger property will be set to null.

Parameters
$init : array<string|int, mixed>|LoggerInterface|string|null = null

Logger initialization data. May be an instance, an array with a logger entry, a string service ID/class name, or null.

$container : ContainerInterface|null = null

Optional dependency injection container used to resolve the logger service.

$useDefault : bool = true

Whether to use LoggerInterface::class as a fallback if $init does not provide a valid logger string. Defaults to true.

Tags
throws
DependencyException

If there is a dependency resolution error.

throws
NotFoundException

If the specified service is not found in the container.

throws
NotFoundExceptionInterface

If the specified service is not found in the container.

throws
ContainerExceptionInterface

If the container encounters a general error.

Return values
static

Returns the current instance for method chaining.

key()

Defines the optional key to find the ressource in the model.

public key([string|null $value = null ]) : $this
Parameters
$value : string|null = null

The key value.

Return values
$this

log()

Logs with an arbitrary level.

public log(mixed $level, string|Stringable $message[, array<string|int, mixed> $context = [] ]) : void
Parameters
$level : mixed
$message : string|Stringable
$context : array<string|int, mixed> = []

model()

Defines the model identifier to find it in the DI container.

public model([string|null $value = null ]) : $this
Parameters
$value : string|null = null

The identifier of the model definition in the DI container.

Return values
$this

notice()

Normal but significant events.

public notice(string|Stringable $message[, array<string|int, mixed> $context = [] ]) : void
Parameters
$message : string|Stringable
$context : array<string|int, mixed> = []

warning()

Exceptional occurrences that are not errors.

public warning(string|Stringable $message[, array<string|int, mixed> $context = [] ]) : void

Example: Use of deprecated APIs, poor use of an API, undesirable things that are not necessarily wrong.

Parameters
$message : string|Stringable
$context : array<string|int, mixed> = []

        
On this page

Search results