public function testEavQueue()
{
// set up Manufacturer records
$field = EavField::getNewInstance('Manufacturer', EavField::DATATYPE_TEXT, EavField::TYPE_TEXT_SIMPLE);
$field->save();
$data = array('first', 'second', 'third');
foreach ($data as $value) {
$manufacturer = Manufacturer::getNewInstance($value);
$manufacturer->getSpecification()->setAttributeValueByLang($field, 'en', $value . ' test');
$manufacturer->save();
}
ActiveRecordModel::clearPool();
// fetch them from database
$manufacturers = ActiveRecordModel::getRecordSetArray('Manufacturer', new ARSelectFilter());
foreach ($manufacturers as &$entry) {
ActiveRecordModel::addToEavQueue('Manufacturer', $entry);
}
// duplicate
$manufacturers = array_merge($manufacturers, $manufacturers);
// load EAV data
ActiveRecordModel::loadEav();
foreach ($manufacturers as $man) {
$this->assertEqual($man['name'] . ' test', $man['attributes'][$field->getID()]['value_en']);
}
}
public function testClone()
{
$text = EavField::getNewInstance('User', EavField::DATATYPE_TEXT, EavField::TYPE_TEXT_SIMPLE);
$text->save();
$singleSel = EavField::getNewInstance('User', EavField::DATATYPE_NUMBERS, EavField::TYPE_NUMBERS_SELECTOR);
$singleSel->handle->set('single.sel');
$singleSel->setValueByLang('name', 'en', 'Select one value');
$singleSel->save();
$value1 = EavValue::getNewInstance($singleSel);
$value1->setValueByLang('value', 'en', $firstValue = '20');
$value1->save();
$value2 = EavValue::getNewInstance($singleSel);
$value2->setValueByLang('value', 'en', $secValue = '30');
$value2->save();
$user = User::getNewInstance('*****@*****.**');
$user->save();
$spec = $user->getSpecification();
$spec->setAttributeValueByLang($text, 'en', 'text');
$spec->setAttributeValue($singleSel, $value1);
$user->save();
$cloned = clone $user;
$cloned->email->set('*****@*****.**');
$cloned->save();
$this->assertNotSame($cloned->getSpecification(), $user->getSpecification());
$this->assertEquals($cloned->getSpecification()->getAttribute($text)->getValueByLang('value', 'en'), 'text');
ActiveRecordModel::clearPool();
$reloaded = ActiveRecordModel::getInstanceByID('User', $cloned->getID(), true);
$this->assertEquals($reloaded->getSpecification()->getAttribute($text)->getValueByLang('value', 'en'), 'text');
$this->assertEquals($reloaded->getSpecification()->getAttribute($singleSel)->getValue()->get()->getID(), $value1->getID());
}
public function testIndex()
{
$response = $this->controller->index();
$this->assertIsA($response, 'ActionResponse');
$nodes = $response->get('nodes');
// +1 for offline methods
$this->assertEqual(count($nodes), count(EavField::getEavClasses()) + 1);
}
/**
* Get new EavFieldGroup active record instance
*
* @return EavFieldGroup
*/
public static function getNewInstance($className)
{
if ($className instanceof EavFieldManager) {
$className = $className->getClassName();
}
$inst = parent::getNewInstance(__CLASS__);
$inst->classID->set(EavField::getClassID($className));
return $inst;
}
public function getSpecificationFieldSet($loadReferencedRecords = false)
{
$f = new ARSelectFilter(new EqualsCond(new ARFieldHandle($this->getFieldClass(), 'classID'), EavField::getClassID($this->owner)));
if ($this->owner->getStringIdentifier()) {
$f->mergeCondition(new EqualsCond(new ARFieldHandle('EavField', 'stringIdentifier'), $this->owner->getStringIdentifier()));
}
$f->setOrder(new ARFieldHandle($this->getFieldClass(), 'position'));
return ActiveRecordModel::getRecordSet($this->getFieldClass(), $f, $loadReferencedRecords);
}
public static function getNewInstance(EavAble $parent)
{
$field = self::getInstanceField($parent);
$instance = parent::getNewInstance(__CLASS__);
$instance->{$field}->set($parent);
$instance->classID->set(EavField::getClassID($parent));
$instance->parent = $parent;
$parent->eavObject->set($instance);
return $instance;
}
public function testCreatingField()
{
$field = EavField::getNewInstance('Manufacturer');
$field->save();
$otherField = EavField::getNewInstance('User');
$otherField->save();
$fields = EavField::getFieldsByClass('Manufacturer');
$this->assertEqual($fields->size(), 1);
$this->assertEqual($fields->get(0), $field);
}
/**
* Creates a select filter for custom fields
*
* @param bool $includeParentFields
* @return ARSelectFilter
*/
private function getFieldFilter($class = null)
{
$classID = $class ? EavField::getClassID($class) : $this->classID;
$filter = new ARSelectFilter(new EqualsCond(new ARFieldHandle('EavField', 'classID'), $classID));
if (is_null($class) && $this->stringIdentifier) {
$filter->mergeCondition(new EqualsCond(new ARFieldHandle('EavField', 'stringIdentifier'), $this->stringIdentifier));
}
$filter->setOrder(new ARFieldHandle('EavFieldGroup', 'position'));
$filter->setOrder(new ARFieldHandle('EavField', 'position'));
return $filter;
}
public function process()
{
static $beenHere = null;
if (!$beenHere) {
EavObject::defineSchema();
$schema = EavField::getSchemaInstance('EavObject');
$schema->registerField(new ARForeignKeyField("eyeExamRequestID", "EyeExamRequest", "ID", null, ARInteger::instance()), false);
$eafFieldInst = EavField::getNewInstance('EavField');
$eafFieldInst->registerClass('EyeExamRequest', 8);
}
$beenHere = true;
}
public function index()
{
$nodes = array();
foreach (EavField::getEavClasses() as $class => $id) {
$nodes[] = array('ID' => $id, 'name' => $this->translate($class));
}
// get offline payment methods
$offlineMethods = array();
foreach (OfflineTransactionHandler::getEnabledMethods() as $method) {
$id = substr($method, -1);
$offlineMethods[] = array('ID' => $method, 'name' => $this->config->get('OFFLINE_NAME_' . $id));
}
if ($offlineMethods) {
$nodes[] = array('ID' => 'offline methods', 'name' => $this->translate('_offline_methods'), 'sub' => $offlineMethods);
}
return new ActionResponse('nodes', $nodes);
}
public function testIndex()
{
$class = 'Category';
$this->request->set('id', EavField::getClassID($class));
$response = $this->controller->index();
$this->assertIsA($response, 'ActionResponse');
// field list should be empty
$this->assertEqual(0, count($response->get('specFieldsWithGroups')));
$field = EavField::getNewInstance($class);
$field->save();
// one new field expected
$response = $this->controller->index();
$this->assertEqual(1, count($response->get('specFieldsWithGroups')));
// the field should not show up in different category
$this->request->set('id', EavField::getClassID('User'));
$response = $this->controller->index();
$this->assertEqual(0, count($response->get('specFieldsWithGroups')));
// test creating a group
$group = EavFieldGroup::getNewInstance($class);
$group->save();
$this->request->set('id', EavField::getClassID($class));
$response = $this->controller->index();
}
private function getSchemaInstance($fieldName)
{
list($schemaName, $fieldName) = explode('.', $fieldName);
if ('eavField' == $schemaName) {
$eavField = EavField::getInstanceByID($fieldName, true);
if (!$eavField->isMultiValue->get()) {
$schemaName = $eavField->getValueTableName();
} else {
// intentionally return wrong schema for multi-select values as they cannot be sorted or searched
$schemaName = 'EavField';
}
}
$possibleSchemas = ActiveRecordModel::getSchemaInstance($this->modelClass)->getDirectlyReferencedSchemas();
if (isset($possibleSchemas[$schemaName])) {
$schema = $possibleSchemas[$schemaName];
} else {
foreach ((array) $possibleSchemas as $name => $schemaArray) {
$parts = explode('_', $name, 2);
if (isset($parts[1]) && $parts[1] == $schemaName) {
$schema = $schemaArray[0];
break;
}
}
}
if (!isset($schema) || !is_object($schema)) {
$schema = ActiveRecordModel::getSchemaInstance($schemaName);
}
if ('EavItem' == $schema->getName()) {
$schema = ActiveRecordModel::getSchemaInstance('EavValue');
}
return $schema;
}
public static function getFieldsByClass($className)
{
$f = new ARSelectFilter(new EqualsCond(new ARFieldHandle('EavField', 'classID'), EavField::getClassID($className)));
$f->setOrder(new ARFieldHandle('EavField', 'position'));
return self::getRecordSet('EavField', $f);
}
