/** * @expectedException zibo\library\orm\exception\OrmException */ public function testRegisterModelWithLocalizationDoesntRegisterLocalizedLinkModelWhenBothLinksAreLocalized() { $field1 = new HasManyField('field1', 'Model2'); $field1->setIsLocalized(true); $model1 = $this->createModel('model1', array($field1)); $field2 = new BelongsToField('field2', 'Model1'); $field2->setIsLocalized(true); $model2 = $this->createModel('model2', array($field2)); $this->register->registerModel($model1); $this->register->registerModel($model2); $localizedModel = $this->register->getModel('model1' . LocalizedModel::MODEL_SUFFIX . 'model2'); }
/** * Processes the next action of this step * return string Name of the next step */ public function next() { try { $this->wizard->validate(); } catch (ValidationException $exception) { Zibo::getInstance()->runEvent(Zibo::EVENT_LOG, $exception->getMessage(), $exception->getTraceAsString()); return null; } $modelTable = $this->wizard->getVariable(BuilderWizard::VARIABLE_MODEL_TABLE); $fieldName = $this->wizard->getValue(self::FIELD_FIELD_NAME); if (!$fieldName) { $this->wizard->setVariable(BuilderWizard::VARIABLE_FIELD); if ($this->wizard->getLimitField()) { return FinishStep::NAME; } return DataFormatStep::NAME; } $field = null; $newField = null; if ($modelTable->hasField($fieldName)) { $field = $modelTable->getField($fieldName); } $fieldType = $this->wizard->getValue(self::FIELD_FIELD_TYPE); if ($fieldType == self::TYPE_PROPERTY) { $propertyType = $this->wizard->getValue(self::FIELD_PROPERTY_TYPE); $propertyDefault = $this->wizard->getValue(self::FIELD_PROPERTY_DEFAULT); $newField = new PropertyField($fieldName, $propertyType, $propertyDefault); if ($field) { $this->copyField($field, $newField); } } else { $relationType = $this->wizard->getValue(self::FIELD_RELATION_TYPE); $relationModel = $this->wizard->getValue(self::FIELD_RELATION_MODEL); switch ($relationType) { case ModelTable::BELONGS_TO: $newField = new BelongsToField($fieldName, $relationModel); break; case ModelTable::HAS_ONE: $newField = new HasOneField($fieldName, $relationModel); break; case ModelTable::HAS_MANY: $newField = new HasManyField($fieldName, $relationModel); $relationOrder = $this->wizard->getValue(self::FIELD_RELATION_ORDER); if ($relationOrder) { $newField->setRelationOrder($relationOrder); } break; } if ($field) { $this->copyField($field, $newField); } $relationLinkModel = $this->wizard->getValue(self::FIELD_RELATION_LINK_MODEL); if ($relationLinkModel && $relationLinkModel != self::AUTOMATIC) { $newField->setLinkModelName($relationLinkModel); } $relationForeignKey = $this->wizard->getValue(self::FIELD_RELATION_FOREIGN_KEY); if ($relationForeignKey && $relationForeignKey != self::AUTOMATIC) { $newField->setForeignKeyName($relationForeignKey); } $relationIsDependant = $this->wizard->getValue(self::FIELD_RELATION_IS_DEPENDANT); if (!$relationIsDependant) { $relationIsDependant = false; } $newField->setIsDependant($relationIsDependant); } $fieldLabel = $this->wizard->getValue(self::FIELD_FIELD_LABEL); if ($fieldLabel) { $newField->setLabel($fieldLabel); } $isLocalized = $this->wizard->getValue(self::FIELD_IS_LOCALIZED); if ($isLocalized === null) { $isLocalized = false; } $newField->setIsLocalized($isLocalized); try { $this->setFieldToModelTable($modelTable, $newField); } catch (Exception $exception) { Zibo::getInstance()->runEvent(Zibo::EVENT_LOG, $exception->getMessage(), $exception->getTraceAsString()); return null; } $limitField = $this->wizard->getLimitField(); if ($limitField && $limitField !== true) { return FinishStep::NAME; } $this->setNextField($fieldName, $modelTable->getFields()); return self::NAME; }
/** * Deletes or clears the values of the provided has many field in the provided data. * @param string $fieldName Name of the has many field * @param zibo\library\orm\definition\field\HasManyField $field Definition of the has many field * @param mixed $data Data obiect * @return null */ private function deleteHasMany($fieldName, HasManyField $field, $data) { $model = $this->meta->getRelationModel($fieldName); if (!$this->meta->isHasManyAndBelongsToMany($fieldName)) { if ($field->isDependant()) { if ($data->{$fieldName}) { foreach ($data->{$fieldName} as $record) { $model->delete($record); } } } else { $this->clearHasMany($this->meta->getRelationModelTable($fieldName), $data->id, true); } return; } $linkModelTable = $this->meta->getRelationLinkModelTable($fieldName); if ($field->isDependant()) { foreach ($data->{$fieldName} as $record) { $model->delete($record); } $keepRecord = false; } else { $fields = $linkModelTable->getFields(); $keepRecord = count($fields) != 3; } $this->clearHasMany($linkModelTable, $data->id, $keepRecord); }
/** * Get the ModelField from a relation field element * @param DOMElement $fieldElement field element in the model element * @param zibo\library\filesystem\File $file the file which is being read * @param string $modelName the model which is currently being processed * @param string $fieldName the field which is currently being processed * @param string $relationModelName the name of the model for which this field is a relation * @return zibo\library\orm\definition\field\ModelField * @throws zibo\library\orm\exception\OrmException when an invalid relation type has been defined */ protected function getRelationFieldFromElement(DOMElement $fieldElement, File $file, $modelName, $fieldName, $relationModelName) { $relationType = $fieldElement->hasAttribute(self::ATTRIBUTE_RELATION) ? $fieldElement->getAttribute(self::ATTRIBUTE_RELATION) : self::DEFAULT_FIELD_RELATION; switch ($relationType) { case self::RELATION_BELONGS_TO: $field = new BelongsToField($fieldName, $relationModelName); break; case self::RELATION_HAS_ONE: $field = new HasOneField($fieldName, $relationModelName); break; case self::RELATION_HAS_MANY: $field = new HasManyField($fieldName, $relationModelName); $relationOrder = $fieldElement->hasAttribute(self::ATTRIBUTE_RELATION_ORDER) ? $fieldElement->getAttribute(self::ATTRIBUTE_RELATION_ORDER) : null; $field->setRelationOrder($relationOrder); $indexOn = $fieldElement->hasAttribute(self::ATTRIBUTE_INDEX_ON) ? $fieldElement->getAttribute(self::ATTRIBUTE_INDEX_ON) : null; $field->setIndexOn($indexOn); $linkModelName = $fieldElement->hasAttribute(self::ATTRIBUTE_LINK_MODEL) ? $fieldElement->getAttribute(self::ATTRIBUTE_LINK_MODEL) : null; $field->setLinkModelName($linkModelName); break; default: throw new OrmException("{$fieldName} of {$modelName} has an invalid relation ({$relationType}) in {$file->getPath()}"); break; } $dependant = $fieldElement->hasAttribute(self::ATTRIBUTE_DEPENDANT) ? Boolean::getBoolean($fieldElement->getAttribute(self::ATTRIBUTE_DEPENDANT)) : false; $field->setIsDependant($dependant); $foreignKey = $fieldElement->hasAttribute(self::ATTRIBUTE_FOREIGN_KEY) ? $fieldElement->getAttribute(self::ATTRIBUTE_FOREIGN_KEY) : null; if ($foreignKey) { $field->setForeignKeyName($foreignKey); } return $field; }
/** * Gets the link model name for a many to many relation * @param zibo\library\orm\definition\field\HasManyField $field1 * @param zibo\library\orm\definition\field\HasManyField $field2 * @param zibo\library\orm\model\meta\ModelMeta $modelMeta Meta of the model of the field * @param string $fieldName Field for the link model * @return string Name of the link model * @throws zibo\library\orm\exception\ModelException when field1 and field2 have the link model set but they are not the same */ private function getManyToManyLinkModelName(HasManyField $field1, HasManyField $field2, ModelMeta $modelMeta, $fieldName) { $linkModelName1 = $field1->getLinkModelName(); $linkModelName2 = $field2->getLinkModelName(); if ($linkModelName1 && $linkModelName2) { if ($linkModelName1 != $linkModelName2) { throw new ModelException('Link model names of ' . $field1->getName() . ' and ' . $field2->getName() . ' are not equal'); } return $linkModelName1; } if ($linkModelName1) { return $linkModelName1; } if ($linkModelName2) { return $linkModelName2; } $modelName1 = $field1->getRelationModelName(); $modelName2 = $field2->getRelationModelName(); $linkModelName = $this->generateLinkModelName($modelName1, $modelName2); return $this->getUniqueLinkModelName($modelMeta, $fieldName, $linkModelName); }
/** * @dataProvider providerSetRelationOrderThrowsExceptionWhenOrderIsInvalid * @expectedException zibo\ZiboException */ public function testSetRelationOrderThrowsExceptionWhenOrderIsInvalid($value) { $field = new HasManyField('name', 'model'); $field->setRelationOrder($value); }