{

/**

protected object $entity;

/**

public function __construct( ?object $entity = null )

{

$class = static::getEntityClass();

if ( $entity ) {

if ( ! $entity instanceof $class ) {

throw new InvalidParameterException( 'Wrong entity type.' );

}

$this->entity = $entity;

}

parent::__construct();

}

public function hasEntity( bool $isPersisted = false ): bool

{

if ( $isPersisted ) {

return ! empty( $this->entity ) && $this->entity->getId();

}

return ! empty( $this->entity );

}

/**

public function getEntity(): ?object

{

return $this->entity ?? null;

}

public function validate(): bool

{

// Create ref if not set yet.

if ( method_exists( $this, 'createRef' ) ) {

$this->createRef( false );

}

if ( $this instanceof Configurable ) {

// Refresh config.

$this->setConfig( $this->entity->getConfig() );

// Any custom config parser methods.

if ( method_exists( $this, 'parseConfig' ) ) {

$this->parseConfig();

}

// Create dependency array from config.

if ( method_exists( $this, 'fetchConfigDependencies' ) ) {

$this->fetchConfigDependencies();

}

}

if ( $this instanceof Supervisable ) {

$this->runSupervisorValidate();

}

return true;

}

/**

public function update( $flush = false, ?EntityManagerInterface $entityManager = null ): void

{

if ( $this->entity->getId() ) {

$this->save( $flush, $entityManager );

}

}

/**

public function save( $flush = false, ?EntityManagerInterface $entityManager = null ): void

{

$success = $this->validate();

if ( $success ) {

$this->persist( $flush, $entityManager );

}

}

/**

public function persist( $flush = false, ?EntityManagerInterface $entityManager = null ): void

{

if ( ! $entityManager ) {

$entityManager = $this->getContainer()->get( 'entitymanager' );

}

$entityManager->persist( $this->entity );

if ( $flush ) {

$entityManager->flush();

}

}

/**

public function delete( $flush = false, ?EntityManagerInterface $entityManager = null ): bool

{

if ( ! $this->hasEntity() ) {

return false; // @todo Or return true?

}

if ( ! $entityManager ) {

$entityManager = $this->getContainer()->get( 'entitymanager' );

}

$entityManager->remove( $this->entity );

if ( $flush ) {

$entityManager->flush();

}

return true;

}

public function normalize( $dependencies = false, $dependents = false ): array

{

return $this->getContainer()->get( ModelNormalizer::class )->normalize( $this, $dependencies, $dependents );

}

public function __call( string $name, array $arguments )

{

if ( ! isset( $this->entity ) || ! is_callable( [ $this->entity, $name ] ) ) {

throw new \ErrorException( 'Method not found: ' . __CLASS__ . '::' . $name );

}

return call_user_func_array( [ $this->entity, $name ], $arguments );

}

/**

public static function create( $entity = null ): static

{

if ( ! $entity ) {

$class = static::getEntityClass();

$entity = new $class();

}

return new static( $entity );

}

public static function get( $entity, $type = null ): ?static

{

if ( $entity instanceof static ) {

return $entity;

}

if ( ! $entity ) {

return null;

}

if ( $type ) {

$model = static::getEntityModelClass( ucfirst( $type ) );

if ( class_exists( $model ) ) {

// @todo is the iterable check even needed?

return $model::get( is_iterable( $entity ) ? $entity['id'] ?? $entity['ref'] ?? $entity : $entity );

}

}

if ( is_object( $entity ) && self::getEntityRealClass( $entity ) === static::getEntityClass() ) {

return static::create( $entity );

}

$repository = static::getRepository();

if ( is_numeric( $entity ) ) {

$entity = $repository->findOneBy( [ 'id' => $entity ] );

} elseif ( is_string( $entity ) ) {

$entity = $repository->findOneBy( [ 'ref' => $entity ] );

} else {

// Only keep valid columns for get query.

$props = array_map( fn($i) => $i->name, ( new \ReflectionClass( static::getEntityClass() ) )?->getProperties() );

$entity = array_intersect_key( $entity, array_flip( $props ) );

if ( ! empty( $entity ) ) {

$entity = $repository->findOneBy( $entity );

}

}

return ( $entity ) ? static::create( $entity ) : null;

}

/**

public static function getAll( array $query = [] ): array

{

if ( empty( static::getEntityClass() ) ) {

return [];

}

$repository = static::getRepository();

if ( $query ) {

$order = $query['orderBy'] ?? $query['order'] ?? $query['sort'] ?? null;

$limit = $query['limit'] ?? $query['max'] ?? null;

$offset = $query['offset'] ?? null;

$where = $query['where'] ?? [];

if ( ! empty( $query['search'] ) && $repository instanceof Searchable ) {

$search = $query['search'];

if ( ! is_array( $search ) ) {

$search = array( 'name' => $search );

}

$entities = $repository->searchBy( $search, $where, $order, $limit, $offset );

} else {

$entities = $repository->findBy( $where, $order, $limit, $offset );

}

} else {

$entities = $repository->findAll();

}

$models = [];

foreach ( $entities as $entity ) {

$models[] = static::create( $entity );

}

return $models;

}

public static function getTotalCount( array $query = [] ): int

{

if ( empty( static::getEntityClass() ) ) {

return 0;

}

$repository = static::getRepository();

return $repository->count( $query['where'] ?? [] );

}

public static function getRepository( ?EntityManagerInterface $entityManager = null ): EntityRepository

{

if ( ! $entityManager ) {

$entityManager = DefaultController::getEntityManager();

}

return $entityManager->getRepository( static::getEntityClass() );

}

public static function getEntityModelClass( $entity ): ?string

{

if ( is_object( $entity ) ) {

$entity = self::getEntityReflection( $entity )->getShortName();

}

return static::getModelClass( $entity );

}

public static function getEntityReflection( $entity ): \ReflectionClass

{

if ( is_object( $entity ) ) {

$entity = get_class( $entity );

}

return \Doctrine\Common\Util\ClassUtils::newReflectionClass( $entity );

}

public static function getEntityRealClass( $entity ): string

{

if ( is_object( $entity ) ) {

$entity = get_class( $entity );

}

return \Doctrine\Common\Util\ClassUtils::getRealClass( $entity );

}

/**

abstract public static function getEntityClass(): string;