/**
  * Constructs a new data format table
  * @param zibo\library\orm\definition\ModelTable $table Table containing the data formats
  * @param string $formatAction URL to the action for the format
  * @return null
  */
 public function __construct(ModelTable $table, $formatAction = null)
 {
     $formats = $table->getDataFormats();
     parent::__construct($formats);
     $this->setId(self::STYLE_ID);
     $this->addDecorator(new ZebraDecorator(new DataFormatDecorator($formatAction)));
 }
 /**
  * Constructs a new model field table
  * @param zibo\library\orm\definition\ModelTable $table Table containing the fields
  * @param string $fieldAction URL to the action of a field
  * @param string $modelAction URL to the action of a model
  * @return null
  */
 public function __construct(ModelTable $table, $tableAction, $fieldAction = null, $modelAction = null)
 {
     $fields = $table->getFields();
     unset($fields[ModelTable::PRIMARY_KEY]);
     parent::__construct($fields, $tableAction, self::NAME);
     $this->addDecorator(new ZebraDecorator(new ModelFieldDecorator($fieldAction, $modelAction)));
     $this->addDecorator(new ModelFieldLabelDecorator());
     $this->addDecorator(new ModelFieldFlagsDecorator());
 }
 /**
  * Constructs a new model field table
  * @param zibo\library\orm\definition\ModelTable $table Table containing the fields
  * @param string $fieldAction URL to the action for the field
  * @return null
  */
 public function __construct(ModelTable $table, $fieldAction = null)
 {
     $fields = $table->getFields();
     unset($fields[ModelTable::PRIMARY_KEY]);
     parent::__construct($fields);
     $this->setId(self::STYLE_ID);
     $this->addDecorator(new ZebraDecorator(new ModelFieldDecorator($fieldAction)));
     $this->addDecorator(new ModelFieldLabelDecorator());
 }
Example #4
0
 protected function createModel($name, array $fields)
 {
     $table = new ModelTable($name);
     foreach ($fields as $field) {
         $table->addField($field);
     }
     $meta = new ModelMeta($table);
     return new SimpleModel($meta);
 }
 /**
  * Constructs a new model index table
  * @param zibo\library\orm\definition\ModelTable $table Table containing the indexes
  * @param string $indexAction URL to the action for the index
  * @return null
  */
 public function __construct(ModelTable $table, $indexAction = null)
 {
     $indexes = $table->getIndexes();
     if (!$indexes) {
         $indexes = array();
     }
     parent::__construct($indexes);
     $this->setId(self::STYLE_ID);
     $this->addDecorator(new ZebraDecorator(new IndexDecorator($indexAction)));
 }
Example #6
0
 /**
  * Parses a has field into the meta
  * @param zibo\library\orm\definition\field\HasField $field
  * @param zibo\library\orm\ModelManager $modelManager Instance of the model manager
  * @return null
  */
 private function parseHasField(HasField $field, ModelManager $modelManager)
 {
     $name = $field->getName();
     $modelName = $this->table->getName();
     $relationModelName = $field->getRelationModelName();
     $relationModel = $modelManager->getModel($relationModelName);
     $relation = new RelationMeta();
     $relation->setIsRelationWithSelf($relationModelName == $modelName);
     $linkModelName = $field->getLinkModelName();
     if ($field->isLocalized()) {
         $localizedMeta = $this->getLocalizedModel()->getMeta();
         $localizedField = $localizedMeta->getField($name);
         $linkModelName = $localizedField->getLinkModelName();
         $field->setLinkModelName($linkModelName);
         $relation->setLinkModelName($linkModelName);
     } elseif ($linkModelName) {
         $relation->setLinkModelName($linkModelName);
         $linkModel = $modelManager->getModel($linkModelName);
         $linkModelTable = $linkModel->getMeta()->getModelTable();
         if (!$relation->isRelationWithSelf()) {
             $relation->setForeignKey($this->getForeignKey($linkModelTable, $relationModelName));
             $relation->setForeignKeyToSelf($this->getForeignKey($linkModelTable, $modelName));
         } else {
             $relation->setForeignKey($this->getForeignKeys($linkModelTable, $modelName));
         }
     } else {
         $relationModelTable = $relationModel->getMeta()->getModelTable();
         $foreignKey = $field->getForeignKeyName();
         $relation->setForeignKey($this->getForeignKey($relationModelTable, $modelName, $foreignKey));
     }
     $this->relations[$name] = $relation;
     if ($field instanceof HasOneField) {
         $this->hasOne[$name] = $field;
         return;
     }
     if ($linkModelName) {
         $relation->setIsHasManyAndBelongsToMany(true);
     }
     $this->hasMany[$name] = $field;
 }
 /**
  * Copies a model table into another
  * @param zibo\library\orm\definition\ModelTable $source
  * @param zibo\library\orm\definition\ModelTable $destination
  * @return null
  */
 private function copyModel(ModelTable $source, ModelTable $destination)
 {
     $destination->setWillBlockDeleteWhenUsed($source->willBlockDeleteWhenUsed);
     $fields = $source->getFields();
     foreach ($fields as $field) {
         if ($field->getName() == ModelTable::PRIMARY_KEY) {
             continue;
         }
         $destination->addField($field);
     }
     $indexes = $source->getIndexes();
     foreach ($indexes as $index) {
         $destination->addIndex($index);
     }
     $dataFormats = $source->getDataFormats();
     foreach ($dataFormats as $name => $format) {
         $destination->setDataFormat($name, $format);
     }
 }
 /**
  * Processes the remove action
  * @param zibo\library\orm\definition\ModelTable $modelTable
  * @return null
  */
 private function processRemove(ModelTable $modelTable, array $remove)
 {
     $remove = array_keys($remove);
     foreach ($remove as $dataFormatName) {
         $modelTable->removeDataFormat($dataFormatName);
     }
     $this->wizard->setVariable(BuilderWizard::VARIABLE_MODEL_TABLE, $modelTable);
     $request = $this->wizard->getRequest();
     $response = $this->wizard->getResponse();
     $response->setRedirect($request->getBasePath());
     return null;
 }
 public function testGetDataFormats()
 {
     $name = 'name';
     $table = new ModelTable('table');
     $formats = $table->getDataFormats(false);
     $this->assertTrue(is_array($formats));
     $this->assertEquals(0, count($formats));
     $formats = $table->getDataFormats(true);
     $this->assertTrue(is_array($formats));
     $this->assertEquals(1, count($formats));
     $this->assertTrue(array_key_exists(DataFormatter::FORMAT_TITLE, $formats));
     $table->setDataFormat(new DataFormat($name, 'format'));
     $formats = $table->getDataFormats(true);
     $this->assertTrue(is_array($formats));
     $this->assertEquals(2, count($formats));
     $this->assertTrue(array_key_exists(DataFormatter::FORMAT_TITLE, $formats));
     $this->assertTrue(array_key_exists($name, $formats));
     $formats = $table->getDataFormats(false);
     $this->assertTrue(is_array($formats));
     $this->assertEquals(1, count($formats));
     $this->assertFalse(array_key_exists(DataFormatter::FORMAT_TITLE, $formats));
     $this->assertTrue(array_key_exists($name, $formats));
     $table->setDataFormat(new DataFormat(DataFormatter::FORMAT_TITLE, 'format'));
     $formats = $table->getDataFormats(true);
     $this->assertTrue(is_array($formats));
     $this->assertEquals(2, count($formats));
     $this->assertTrue(array_key_exists(DataFormatter::FORMAT_TITLE, $formats));
     $this->assertTrue(array_key_exists($name, $formats));
     $formats = $table->getDataFormats(false);
     $this->assertTrue(is_array($formats));
     $this->assertEquals(2, count($formats));
     $this->assertTrue(array_key_exists(DataFormatter::FORMAT_TITLE, $formats));
     $this->assertTrue(array_key_exists($name, $formats));
 }
Example #10
0
 /**
  * Sets the submitted field to the model table
  * @param zibo\library\orm\definition\ModelTable $modelTable
  * @param zibo\library\orm\definition\field\ModelField $field
  * @return null
  */
 private function setFieldToModelTable(ModelTable $modelTable, ModelField $field)
 {
     $modelTable->setField($field);
     $fieldName = $field->getName();
     $currentFieldName = $this->wizard->getVariable(BuilderWizard::VARIABLE_FIELD);
     if (!$currentFieldName || $fieldName == $currentFieldName) {
         $this->wizard->setVariable(BuilderWizard::VARIABLE_MODEL_TABLE, $modelTable);
         return;
     }
     $order = array();
     $fields = $modelTable->getFields();
     foreach ($fields as $modelFieldName => $modelField) {
         if ($modelFieldName == $fieldName) {
             continue;
         }
         if ($modelFieldName == $currentFieldName) {
             $modelFieldName = $fieldName;
         }
         $order[] = $modelFieldName;
     }
     $modelTable->orderFields($order);
     $modelTable->removeField($currentFieldName);
     $this->wizard->setVariable(BuilderWizard::VARIABLE_MODEL_TABLE, $modelTable);
 }
Example #11
0
 /**
  * Deletes or clears, depending on the keepRecord argument, the values of the provided table
  * which have a relation with the provided data
  * @param zibo\library\orm\definition\ModelTable $modelTable Table definition of the model of the has many relation
  * @param integer $id Primary key of the data
  * @param boolean $keepRecord True to clear the link, false to delete the link
  * @return null
  */
 private function clearHasMany(ModelTable $modelTable, $id, $keepRecord)
 {
     $table = new TableExpression($modelTable->getName());
     $relationFields = $modelTable->getRelationFields($this->getName());
     $fields = $relationFields[ModelTable::BELONGS_TO];
     foreach ($fields as $field) {
         $fieldName = $field->getName();
         if ($keepRecord) {
             $statement = new UpdateStatement();
             $statement->addValue(new FieldExpression($fieldName), null);
         } else {
             $statement = new DeleteStatement();
         }
         $condition = new SimpleCondition(new FieldExpression($fieldName), new SqlExpression($id), Condition::OPERATOR_EQUALS);
         $statement->addTable($table);
         $statement->addCondition($condition);
         $this->executeStatement($statement);
     }
     $model = $this->getModel($modelTable->getName());
     $model->clearCache();
 }
Example #12
0
 /**
  * Gets the foreign keys from the provided model table for the provided relation model. When no foreign keys are found and the relation
  * model is a localized model, the unlocalized model will be queried for the foreign keys.
  * @param zibo\library\orm\definition\ModelTable $modelTable Table definition of the model
  * @param string $relationModelName Model name to get the foreign keys of
  * @return array Array with ModelField objects
  * @throws zibo\library\orm\exception\ModelException when there are no foreign keys found the provided model
  */
 private function getForeignKeys(ModelTable $modelTable, $relationModelName)
 {
     if (!$relationModelName) {
         throw new ModelException('Provided relation model name is empty');
     }
     $foreignKeys = $modelTable->getRelationFields($relationModelName, ModelTable::BELONGS_TO);
     if (!$foreignKeys) {
         if (preg_match('/' . LocalizedModel::MODEL_SUFFIX . '$/', $relationModelName)) {
             $relationModelName = substr($relationModelName, 0, strlen(LocalizedModel::MODEL_SUFFIX) * -1);
             $foreignKeys = $modelTable->getRelationFields($relationModelName, ModelTable::BELONGS_TO);
         }
         if (!$foreignKeys) {
             throw new ModelException('No foreign key found for ' . $relationModelName . ' found in ' . $modelTable->getName());
         }
     }
     return $foreignKeys;
 }
Example #13
0
 /**
  * Sets the the title and teaser format to the model table
  * @param DOMElement $modelElement Element of the model
  * @param zibo\library\orm\definition\ModelTable $modelTable Model table which is being read
  * @return null
  */
 protected function setFormatsFromElement(DOMElement $modelElement, ModelTable $modelTable)
 {
     $formatElements = $modelElement->getElementsByTagName(self::TAG_FORMAT);
     foreach ($formatElements as $formatElement) {
         $name = $formatElement->getAttribute(self::ATTRIBUTE_NAME);
         $format = $formatElement->textContent;
         $modelTable->setDataFormat(new DataFormat($name, $format));
     }
 }
Example #14
0
 /**
  * Creates a link model and registers it
  * @param string $linkModelName Name of the new link model
  * @param string $modelName1 Name of the first model
  * @param string $modelName2 Name of the second model
  * @return zibo\library\orm\model\Model The registered model
  */
 private function createAndRegisterLinkModel($linkModelName, $modelName1, $modelName2)
 {
     $table = new ModelTable($linkModelName);
     $indexName = lcfirst($this->generateLinkModelName($modelName1, $modelName2));
     $fieldName1 = lcfirst($modelName1);
     $fieldName2 = lcfirst($modelName2);
     if ($modelName1 == $modelName2) {
         $field1 = new BelongsToField($fieldName1 . '1', $modelName1);
         $field2 = new BelongsToField($fieldName1 . '2', $modelName2);
     } else {
         $field1 = new BelongsToField($fieldName1, $modelName1);
         $field2 = new BelongsToField($fieldName2, $modelName2);
     }
     $index = new Index($indexName, array($field1, $field2));
     $table->addField($field1);
     $table->addField($field2);
     $table->addIndex($index);
     $linkModel = new SimpleModel(new ModelMeta($table));
     $this->registerModel($linkModel, false);
     return $linkModel;
 }