/**
* Create validator based on config.
* @param AnnotatedInterface $model
* @param ValidatorMeta $validatorMeta
* @return ValidatorInterface Validator instance
*/
public static function create(AnnotatedInterface $model, ValidatorMeta $validatorMeta, $fieldName = null)
{
$mn = Mangan::fromModel($model);
// Resolve validator class
if ($validatorMeta->proxy && empty($validatorMeta->class)) {
if (isset($mn->validators[$validatorMeta->proxy])) {
$validatorMeta->class = $mn->validators[$validatorMeta->proxy];
} else {
if (empty($fieldName)) {
$fieldName = '<not provided>';
}
$args = [get_class($model), $validatorMeta->proxy, $fieldName];
$msg = vsprintf("Could not resolve validator class from proxy. For model `%s`. Proxy class: `%s`. Model field: `%s`", $args);
throw new InvalidArgumentException($msg);
}
}
if (empty($validatorMeta->class)) {
$args = [get_class($model)];
$msg = vsprintf("Empty validator class for model `%s`", $args);
throw new InvalidArgumentException($msg);
}
$config = (array) $validatorMeta;
unset($config['proxy']);
$di = $mn->getDi();
return $di->apply($config);
}
public function __construct($scenario = 'insert', $lang = '')
{
parent::__construct($scenario, $lang);
$this->_id = new MongoId();
$mangan = Mangan::fromModel($this);
$this->_db = $mangan->getDbInstance();
}
public function __construct(AnnotatedInterface $model = null)
{
$this->model = $model;
if (!$model) {
$this->mn = Mangan::fly();
return;
}
$this->mn = Mangan::fromModel($model);
}
public static function toModel($transformerClass, AnnotatedInterface $model)
{
$plugins = PluginFactory::fly()->instance(Mangan::fromModel($model)->finalizers, $transformerClass, ModelFinalizerInterface::class);
foreach ($plugins as $finalizer) {
/* @var $finalizer ArrayFinalizerInterface */
$finalizer->toModel($model);
}
return $model;
}
public function testIfManganHasProperlyConfiguredFilters()
{
$model = new ExplicitlyNonIndexableField();
// Check if mangan has properly configured filters
$mangan = Mangan::fromModel($model);
$filterConfig = $mangan->filters;
$this->assertTrue(array_key_exists(SearchArray::class, $filterConfig), 'That SearchArray filters are configured');
$this->assertTrue(in_array(SearchFilter::class, $filterConfig[SearchArray::class]), 'That SearchFilter is configured');
}
public function __construct($model)
{
// This is to use get/set
foreach ($this->_getOptionNames() as $name) {
PropertyMaker::defineProperty($this, $name, $this->_defaults);
}
foreach (ManganMeta::create($model)->type()->clientFlags as $name => $value) {
$this->_values[$name] = $value;
}
$this->_mangan = Mangan::fromModel($model);
}
/**
* Constructor
*
* @param object $model Model instance
* @param EntityManagerInterface $em
* @param Mangan $mangan
*/
public function __construct($model, $em = null, $mangan = null)
{
$this->model = $model;
$this->sm = new ScopeManager($model);
if (null === $mangan) {
$mangan = Mangan::fromModel($model);
}
$this->em = $em ?: EntityManager::create($model, $mangan);
$this->mn = $mangan;
$this->withCursor($this->mn->useCursor);
}
public function index()
{
if (!$this->isIndexable) {
return;
}
// NOTE: Transformer must ensure that _id is string, not MongoId
$body = SearchArray::fromModel($this->model);
if (array_key_exists('_id', $body)) {
$config = Mangan::fromModel($this->model)->sanitizersMap;
if (!array_key_exists(SearchArray::class, $config)) {
throw new UnexpectedValueException(sprintf('Mangan is not properly configured for Manganel. Signals must be generated or add configuration manually from `%s::getDefault()`', ConfigManager::class));
} else {
throw new UnexpectedValueException(sprintf('Cannot index `%s`, as it contains _id field. Either use MongoObjectId sanitizer on it, or rename.', get_class($this->model)));
}
}
// In some cases $value *might* still be mongoId type,
// see https://github.com/Maslosoft/Addendum/issues/43
$func = function ($value) {
if ($value instanceof MongoId) {
return (string) $value;
}
return $value;
};
$filtered = filter_var($body, \FILTER_CALLBACK, ['options' => $func]);
// Create proper elastic search request array
$params = ['body' => $filtered];
try {
$this->getClient()->index($this->getParams($params));
} catch (BadRequest400Exception $e) {
// Throw previous exception,
// as it holds more meaningfull information
$previous = $e->getPrevious();
$message = sprintf('Exception while indexing `%s`@`%s`: %s', get_class($this->model), $this->manganel->indexId, $previous->getMessage());
throw new BadRequest400Exception($message);
}
}
/**
* Create entity manager
* @param AnnotatedInterface $model
* @param Mangan $mangan
* @throws ManganException
*/
public function __construct(AnnotatedInterface $model, Mangan $mangan = null)
{
$this->model = $model;
$this->sm = new ScopeManager($model);
$this->options = new EntityOptions($model);
$this->collectionName = CollectionNamer::nameCollection($model);
$this->meta = ManganMeta::create($model);
$this->validator = new Validator($model);
if (null === $mangan) {
$mangan = Mangan::fromModel($model);
}
if (!$this->collectionName) {
throw new ManganException(sprintf('Invalid collection name for model: `%s`', $this->meta->type()->name));
}
$this->_collection = new MongoCollection($mangan->getDbInstance(), $this->collectionName);
}
public function __construct(AnnotatedInterface $model = null)
{
parent::__construct($model);
$this->available = new CommandProxyStorage($this, Mangan::fromModel($model)->connectionId);
}
