The annotations problem

these code can run my own mac ,but in ubuntu get some error?

ErrorException: Invalid argument supplied for foreach() /Form.php (376) BacktraceRequestServerIncluded FilesMemoryVariables

0 unknown

/Form.php (376) }

public function initializeFormAnnotations()
{
    $reader = new Annotations();
    $formProperties = $reader->getProperties(get_class($this));

    foreach ($formProperties as $key => $property) {
        //$formProperty = isset($formProperties[$key]) ? $formProperties[$key] : null;
        $element = $this->createElementByProperty($key, $property);
        if ($element && $element instanceof ElementInterface) {
            $this->add($element);
        }

The Code:

<?php

namespace Eva\EvaEngine;

use Eva\EvaEngine\Exception\StandardException; use Eva\EvaEngine\Forms\FormMiddleWareInterface; use Phalcon\Annotations\Collection as Property; use Phalcon\Mvc\Model as PhalconModel; use Phalcon\Annotations\Adapter\Memory as Annotations; use Phalcon\Forms\ElementInterface; use Phalcon\Http\Response;

class Form extends \Phalcon\Forms\Form { /**

  • @var string */ protected $prefix;

    /**

  • @var */ protected $exclude;

    /**

  • @var */ protected $model;

    /**

  • @var */ protected $values = [];

    /**

  • @var */ protected $formset;

    /**

  • @var */ protected $relationKey;

    /**

  • @var Form */ protected $parentForm;

    /**

  • @var string */ protected $defaultModelClass;

    /**

  • @var bool */ protected $initializedWithModel = false;

    /**

  • @var array */ protected $rawPostData = array();

    /**

  • @var array */ protected $elementAlias = array( 'check' => 'Phalcon\Forms\Element\Check', 'date' => 'Phalcon\Forms\Element\Date', 'email' => 'Phalcon\Forms\Element\Email', 'file' => 'Phalcon\Forms\Element\File', 'hidden' => 'Phalcon\Forms\Element\Hidden', 'numeric' => 'Phalcon\Forms\Element\Numeric', 'number' => 'Phalcon\Forms\Element\Numeric', 'password' => 'Phalcon\Forms\Element\Password', 'select' => 'Phalcon\Forms\Element\Select', 'submit' => 'Phalcon\Forms\Element\Submit', 'text' => 'Phalcon\Forms\Element\Text', 'textarea' => 'Phalcon\Forms\Element\TextArea', );

    /**

  • @var array */ protected $validatorAlias = array( 'between' => 'Phalcon\Validation\Validator\Between', 'confirmation' => 'Phalcon\Validation\Validator\Confirmation', 'email' => 'Phalcon\Validation\Validator\Email', 'exclusionin' => 'Phalcon\Validation\Validator\ExclusionIn', 'exclusion' => 'Phalcon\Validation\Validator\ExclusionIn', 'identical' => 'Phalcon\Validation\Validator\Identical', 'inclusionin' => 'Phalcon\Validation\Validator\InclusionIn', 'inclusion' => 'Phalcon\Validation\Validator\InclusionIn', 'presenceof' => 'Phalcon\Validation\Validator\PresenceOf', 'regex' => 'Phalcon\Validation\Validator\Regex', 'stringlength' => 'Phalcon\Validation\Validator\StringLength', );

    /**

  • @var FormMiddlewareInterface */ protected $middleware;

    public function getMiddleware() { return $this->middleware; }

    public function setMiddleware(FormMiddleWareInterface $middleware) { $this->middleware = $middleware;

    return $this;

    }

    public function getRelationKey() { return $this->relationKey; }

    public function setRelationKey($key) { $this->relationKey = $key;

    return $this;

    }

    public function getDefaultModelClass() { return $this->defaultModelClass; }

    public function setDefaultModelClass($model) { $this->defaultModelClass = $model;

    return $this;

    }

    public function setParentForm($form) { $this->parentForm = $form;

    return $this;

    }

    public function getParentForm() { return $this->parentForm; }

    public function getRawPostData() { return $this->rawPostData; }

    public function setRawPostData($data) { $this->rawPostData = $data;

    return $this;

    }

    /**

  • @deprecated need to fix under phalcon2
  • @param string $name
  • @return mixed */ public function getValue($name) { return parent::getValue($name); }

    public function getValues() { return $this->values; }

    public function setValues(array $data) { if (!$data) { return $this; } foreach ($data as $key => $value) { if ($this->has($key)) { $this->get($key)->setDefault($value); } } $this->values = $data;

    return $this;

    }

    public function setPrefix($prefix) { $this->prefix = $prefix; if (!$this->model) { return $this; }

    /*
    $elements = $this->_elements;
    foreach ($elements as $key => $element) {
        $element->setName($prefix . '[' . $element->getName() . ']');
    }
    */
    
    return $this;

    }

    public function getPrefix() { return $this->prefix; }

    public function setExclude($exclude) { $this->exclude = $exclude;

    return $this;

    }

    public function getExclude() { return $this->exclude; }

    public function getFormset() { return $this->formset; }

    public function setFormset($formset) { $this->formset = $formset;

    return $this;

    }

    public function getFullMessages() { if (!$this->formset) { return $this->getMessages(); }

    $messages = $this->getMessages();
    foreach ($this->formset as $key => $form) {
        if ($subForm = $this->getForm($key)) {
            $messages->appendMessages($subForm->getMessages());
        }
    }
    
    return $messages;

    }

    public function getForm($formKey) { if (!isset($this->formset[$formKey])) { return false; }

    $form = $this->formset[$formKey];
    $form->initializeWithModel();
    
    return $form;

    }

    public function setModel(PhalconModel $model, $autoParse = true) { $this->model = $model; $this->setEntity($model); $reader = new Annotations(); $modelProperties = $reader->getProperties(get_class($model)); $formProperties = $reader->getProperties(get_class($this)); foreach ($modelProperties as $key => $property) { //already added in initialize if ($this->has($key)) { continue; } $formProperty = isset($formProperties[$key]) ? $formProperties[$key] : null; $element = $this->createElementByProperty($key, $property, $formProperty); if ($element) { $this->add($element); } } $this->afterSetModel();

    return $this;

    }

    public function afterSetModel() { //callback }

    public function isFullValid($data = null, $entity = null) { $data = $data ?: $this->values; $this->setRawPostData($data);

    if (!$this->formset) {
        $entity = $entity ? $entity : $this->model;
    
        return $this->isValid($data, $entity);
    }
    
    $formCount = count($this->formset);
    $validResult = 0;
    foreach ($this->formset as $key => $subForm) {
        $form = $this->getForm($key);
        if (isset($data[$key])) {
            if ($form->isValid($data[$key], $form->getModel())) {
                $validResult++;
            }
        } else {
            $validResult++;
        }
    }
    
    $this->bind($data, $this->getModel());
    if ($this->isValid($data, $this->getModel())) {
        $validResult++;
    }
    
    return $validResult === $formCount + 1 ? true : false;

    }

    public function save($modelSaveMethod = 'save') { if (!$model = $this->model) { return $this; }

    if ($this->formset) {
        foreach ($this->formset as $relationKey => $subForm) {
            $relationModel = $this->getModel($relationKey);
            if ($model) {
                $model->$relationKey = $relationModel;
            }
        }
    }
    
    $model->setModelForm($this);
    if ($modelSaveMethod == 'save') {
        if (!$model->save()) {
            throw new Exception\RuntimeException(get_class($model) . ' save failed');
        }
    
        return $model;
    } else {
        return $model->$modelSaveMethod($this->getRawPostData());
    }

    }

    public function initializeFormAnnotations() { $reader = new Annotations(); $formProperties = $reader->getProperties(get_class($this));

    foreach ($formProperties as $key => $property) {
        //$formProperty = isset($formProperties[$key]) ? $formProperties[$key] : null;
        $element = $this->createElementByProperty($key, $property);
        if ($element && $element instanceof ElementInterface) {
            $this->add($element);
        }
    }
    
    return $this;

    }

    public function registerElementAlias($elementAlias, $elementClass) { $this->elementAlias[$elementAlias] = $elementClass;

    return $this;

    }

    public function getElementAlias() { return $this->elementAlias; }

    public function getModel($modelName = null) { if (!$modelName) { return $this->model; }

    //Get model from subform when model name not null
    if ($this->getForm($modelName)) {
        return $this->getForm($modelName)->getModel();
    }
    
    return $this->model;

    }

    public function render($name, $attributes = null) { $element = $this->get($name); $element = $this->middleware ? $this->middleware->pipeElement($element) : $element; $attributes = $attributes ? (array)$attributes : [];

    if (!$this->prefix) {
        return parent::render($element->getName(), array_merge($element->getAttributes(), $attributes));
    }
    $attributes = array_merge(
        $element->getAttributes(),
        [
            'name' => $this->prefix . '[' . $element->getName() . ']',
        ],
        $attributes
    );
    
    return parent::render($name, $attributes);

    }

    /*

    • Simple usage
    • $userForm->addForm('Profile', 'Eva\EvaUser\Forms\ProfileForm');
    • Full usage
    • $userForm->addForm('Profile', array( 'form' => 'Eva\EvaUser\Forms\ProfileForm', 'relationKey' => 'Profile', 'relation' => 'hasOne', 'relationModel' => 'Eva\EvaUser\Models\Profile', ));
    • */ public function addForm($prefix, $formOptions) { if (is_string($formOptions)) { $formClass = new $formOptions(); } else { $formClass = isset($formOptions['form']) ? new $formOptions['form']() : null; }

      if (!($formClass instanceof Form)) { throw new Exception\InvalidArgumentException( sprintf('Add formset failed by incorrect form class instance %s', $prefix) ); }

      $formClass->setPrefix($prefix);
      $relationKey =
      is_array($formOptions)
      && isset($formOptions['relationKey'])
      ? $formOptions['relationKey']
      $prefix; $formClass->setRelationKey($relationKey); $relationModel = is_array($formOptions) && isset($formOptions['relationModel']) ? $formOptions['relationModel']
      null; if ($relationModel) { $formClass->setDefaultModelClass($relationModel); }

      $this->formset[$prefix] = $formClass; $formClass->setParentForm($this);

      return $this; }

    public function initializeWithModel() { if ($this->initializedWithModel || !$this->parentForm || !$this->relationKey) { return $this; }

    $relationKey = $this->relationKey;
    $model = $this->parentForm->getModel();
    
    if (isset($model->$relationKey) && $model->$relationKey) {
        $this->setModel($model->$relationKey);
    } else {
        $defaultModelClass = $this->getDefaultModelClass();
        if (!$defaultModelClass || false == class_exists($defaultModelClass)) {
            throw new Exception\RuntimeException(
                sprintf('Form connected to incorrect model %s', $defaultModelClass)
            );
        }
        $this->setModel(new $defaultModelClass());
    }
    $this->initializedWithModel = true;
    
    return $this;

    }

    protected function createElementByProperty($elementName, Property $baseProperty, Property $mergeProperty = null) { $elementType = 'Phalcon\Forms\Element\Text'; if (!$baseProperty && !$mergeProperty) { return new $elementType($elementName); }

    $property = $mergeProperty && $mergeProperty->has('Type') ? $mergeProperty : $baseProperty;
    if ($property->has('Type')) {
        $typeArguments = $property->get('Type')->getArguments();
        $alias = isset($typeArguments[0]) ? strtolower($typeArguments[0]) : null;
        $elementType = isset($this->elementAlias[$alias]) ? $this->elementAlias[$alias] : $elementType;
    }
    
    $property = $mergeProperty && $mergeProperty->has('Name') ? $mergeProperty : $baseProperty;
    if ($property->has('Name')) {
        $arguments = $property->get('Name')->getArguments();
        $elementName = isset($arguments[0]) ? $arguments[0] : $elementName;
    }
    $element = new $elementType($elementName);
    
    $property = $mergeProperty && $mergeProperty->has('Attr') ? $mergeProperty : $baseProperty;
    if ($property->has('Attr')) {
        $element->setAttributes($property->get('Attr')->getArguments());
    }
    
    $addValidator = function ($property, $element, $validatorAlias) {
        foreach ($property as $annotation) {
            if ($annotation->getName() != 'Validator') {
                continue;
            }
            $arguments = $annotation->getArguments();
            if (!isset($arguments[0])) {
                continue;
            }
            $validatorName = strtolower($arguments[0]);
            if (!isset($validatorAlias[$validatorName])) {
                continue;
            }
            $validator = $validatorAlias[$validatorName];
            $element->addValidator(new $validator($arguments));
        }
    
        return $element;
    };
    if ($baseProperty->has('Validator')) {
        $element = $addValidator($baseProperty, $element, $this->validatorAlias);
    }
    if ($mergeProperty && $mergeProperty->has('Validator')) {
        $element = $addValidator($mergeProperty, $element, $this->validatorAlias);
    }
    
    $addFilter = function ($property, $element) {
        foreach ($property as $annotation) {
            if ($annotation->getName() != 'Filter') {
                continue;
            }
            $arguments = $annotation->getArguments();
            if (!isset($arguments[0])) {
                continue;
            }
            $filterName = strtolower($arguments[0]);
            $element->addFilter($filterName);
        }
    
        return $element;
    };
    if ($baseProperty->has('Filter')) {
        $element = $addFilter($baseProperty, $element);
    }
    if ($mergeProperty && $mergeProperty->has('Filter')) {
        $element = $addFilter($mergeProperty, $element);
    }
    
    $property = $mergeProperty && $mergeProperty->has('Options') ? $mergeProperty : $baseProperty;
    if ($property->has('Options')) {
        $element->setAttributes($property->get('Options')->getArguments());
    }
    
    $addOption = function ($property, $element) {
        $options = array();
        foreach ($property as $annotation) {
            if ($annotation->getName() != 'Option') {
                continue;
            }
            $options += $annotation->getArguments();
        }
        $element->setOptions($options);
    
        return $element;
    };
    
    if ($baseProperty->has('Option')) {
        $element = $addOption($baseProperty, $element);
    }
    if ($mergeProperty && $mergeProperty->has('Option')) {
        $element = $addOption($mergeProperty, $element);
    }
    
    return $element;

    } }

create un gist and share with config.php and services.php