PHP RedBeanModel类代码示例

 public function __construct(RedBeanModel $model = null, $attributeName = null)
 {
     assert('$attributeName === null || is_string($attributeName)');
     assert('$model === null || $model->isAttribute($attributeName)');
     if ($model !== null) {
         $this->attributeName = $attributeName;
         $this->attributeLabels = $model->getAttributeLabelsForAllActiveLanguagesByAttributeName($attributeName);
         $this->attributePropertyToDesignerFormAdapter = new AttributePropertyToDesignerFormAdapter();
         $validators = $model->getValidators($attributeName);
         foreach ($validators as $validator) {
             if ($validator instanceof CDefaultValueValidator) {
                 $this->defaultValue = $validator->value;
             } elseif ($validator instanceof CRequiredValidator) {
                 $this->isRequired = true;
                 $modelAttributesAdapter = new ModelAttributesAdapter($model);
                 if ($modelAttributesAdapter->isStandardAttribute($attributeName) && $modelAttributesAdapter->isStandardAttributeRequiredByDefault($attributeName)) {
                     $this->attributePropertyToDesignerFormAdapter->setUpdateRequiredFieldStatus(false);
                 }
             }
         }
         if ($model instanceof Item && $attributeName != null) {
             $this->isAudited = $model->isAttributeAudited($attributeName);
         }
     }
 }

 /**
  * Copy the account from a related model to a activity items
  * @param RedBeanModel $model
  * @param RedBeanModel $relatedModel
  */
 protected function addRelatedModelAccountToModel(RedBeanModel $model, RedBeanModel $relatedModel)
 {
     $metadata = Activity::getMetadata();
     if ($relatedModel->isRelation('account') && isset($relatedModel->account) && $relatedModel->account->id > 0 && in_array(get_class($relatedModel->account), $metadata['Activity']['activityItemsModelClassNames'])) {
         $model->activityItems->add($relatedModel->account);
     }
 }

 public static function processAfterCopy(RedBeanModel $model, RedBeanModel $copyToModel)
 {
     foreach ($model->tasks as $task) {
         $copyToTask = new Task();
         TaskActivityCopyModelUtil::copy($task, $copyToTask);
         $copyToTask->status = Task::STATUS_NEW;
         $copyToModel->tasks->add($copyToTask);
     }
     $copyToModel->save();
 }

 /**
  *
  * Get model properties as array.
  * return array
  */
 public function getData()
 {
     $data = array();
     $data['id'] = $this->model->id;
     $retrievableAttributes = static::resolveRetrievableAttributesByModel($this->model);
     foreach ($this->model->getAttributes($retrievableAttributes) as $attributeName => $notUsed) {
         $type = ModelAttributeToMixedArrayTypeUtil::getType($this->model, $attributeName);
         $adapterClassName = $type . 'RedBeanModelAttributeValueToArrayValueAdapter';
         if ($type != null && @class_exists($adapterClassName) && !($this->model->isRelation($attributeName) && $this->model->getRelationType($attributeName) != RedBeanModel::HAS_ONE)) {
             $adapter = new $adapterClassName($this->model, $attributeName);
             $adapter->resolveData($data);
         } elseif ($this->model->isOwnedRelation($attributeName) && ($this->model->getRelationType($attributeName) == RedBeanModel::HAS_ONE || $this->model->getRelationType($attributeName) == RedBeanModel::HAS_MANY_BELONGS_TO)) {
             if ($this->model->{$attributeName}->id > 0) {
                 $util = new ModelToArrayAdapter($this->model->{$attributeName});
                 $relatedData = $util->getData();
                 $data[$attributeName] = $relatedData;
             } else {
                 $data[$attributeName] = null;
             }
         } elseif ($this->model->isRelation($attributeName) && $this->model->getRelationType($attributeName) == RedBeanModel::HAS_ONE) {
             if ($this->model->{$attributeName}->id > 0) {
                 $data[$attributeName] = array('id' => $this->model->{$attributeName}->id);
             } else {
                 $data[$attributeName] = null;
             }
         }
     }
     return $data;
 }

 /**
  * Given a model and attributeName, get the min length for that attribute as defined by the metadata rules.
  * @param object $model RedBeanModel
  * @param string $attributeName
  */
 public static function getMinLengthByModelAndAttributeName(RedBeanModel $model, $attributeName)
 {
     assert('is_string($attributeName)');
     $validators = $model->getValidators($attributeName);
     $minLength = null;
     foreach ($validators as $validator) {
         if ($validator instanceof CStringValidator) {
             if ($validator->min !== null) {
                 $minLength = $validator->min;
                 break;
             }
         }
     }
     return $minLength;
 }

 public static function setUpBeforeClass()
 {
     parent::setUpBeforeClass();
     ZurmoDatabaseCompatibilityUtil::dropStoredFunctionsAndProcedures();
     SecurityTestHelper::createSuperAdmin();
     SecurityTestHelper::createUsers();
     SecurityTestHelper::createGroups();
     SecurityTestHelper::createRoles();
     RedBeanModel::forgetAll();
     //do the rebuild to ensure the tables get created properly.
     ReadPermissionsOptimizationUtil::rebuild();
     //Manually build the test model munge tables.
     ReadPermissionsOptimizationUtil::recreateTable(ReadPermissionsOptimizationUtil::getMungeTableName('OwnedSecurableTestItem'));
     ReadPermissionsOptimizationUtil::recreateTable(ReadPermissionsOptimizationUtil::getMungeTableName('OwnedSecurableTestItem2'));
     $benny = User::getByUsername('benny');
     $model = new OwnedSecurableTestItem();
     $model->member = 'test';
     assert($model->save());
     // Not Coding Standard
     $model = new OwnedSecurableTestItem();
     $model->member = 'test2';
     assert($model->save());
     // Not Coding Standard
     $model = new OwnedSecurableTestItem();
     $model->member = 'test3';
     $model->owner = $benny;
     assert($model->save());
     // Not Coding Standard
     assert(OwnedSecurableTestItem::getCount() == 3);
     // Not Coding Standard
     $model = new OwnedSecurableTestItem2();
     $model->member = 'test5';
     assert($model->save());
     // Not Coding Standard
 }

 protected static function generateCampaignItems($campaign, $pageSize)
 {
     if ($pageSize == null) {
         $pageSize = self::DEFAULT_CAMPAIGNITEMS_TO_CREATE_PAGE_SIZE;
     }
     $contacts = array();
     $quote = DatabaseCompatibilityUtil::getQuote();
     $marketingListMemberTableName = RedBeanModel::getTableName('MarketingListMember');
     $campaignItemTableName = RedBeanModel::getTableName('CampaignItem');
     $sql = "select {$quote}{$marketingListMemberTableName}{$quote}.{$quote}contact_id{$quote} from {$quote}{$marketingListMemberTableName}{$quote}";
     // Not Coding Standard
     $sql .= "left join {$quote}{$campaignItemTableName}{$quote} on ";
     $sql .= "{$quote}{$campaignItemTableName}{$quote}.{$quote}contact_id{$quote} ";
     $sql .= "= {$quote}{$marketingListMemberTableName}{$quote}.{$quote}contact_id{$quote}";
     $sql .= "AND {$quote}{$campaignItemTableName}{$quote}.{$quote}campaign_id{$quote} = " . $campaign->id . " ";
     $sql .= "where {$quote}{$marketingListMemberTableName}{$quote}.{$quote}marketinglist_id{$quote} = " . $campaign->marketingList->id;
     $sql .= " and {$quote}{$campaignItemTableName}{$quote}.{$quote}id{$quote} is null limit " . $pageSize;
     $ids = R::getCol($sql);
     foreach ($ids as $contactId) {
         $contacts[] = Contact::getById((int) $contactId);
     }
     if (!empty($contacts)) {
         //todo: if the return value is false, then we might need to catch that since it didn't go well.
         CampaignItem::registerCampaignItemsByCampaign($campaign, $contacts);
         if (count($ids) < $pageSize) {
             return true;
         }
     } else {
         return true;
     }
     return false;
 }

 /**
  * Adds a related model.
  */
 public function add(RedBeanModel $model)
 {
     assert("\$model instanceof {$this->modelClassName}");
     assert('!$this->contains($model)');
     assert('($oldCount = $this->count()) > -1');
     // To save the value only when asserts are enabled.
     $bean = $model->getClassBean($this->modelClassName);
     $this->deferredRelateBeans[] = $bean;
     if (in_array($bean, $this->deferredUnrelateBeans)) {
         self::array_remove_object($this->deferredUnrelateBeans, $bean);
     }
     $this->relatedBeansAndModels[] = $model;
     $this->modified = true;
     assert('$this->count() == $oldCount + 1');
     assert('$this->contains($model)');
 }

 /**
  * @param @modelClassName - the main 'from part' table is this model's table. This is considered the base table
  */
 public function __construct($modelClassName)
 {
     assert('is_string($modelClassName)');
     $tableName = RedBeanModel::getTableName($modelClassName);
     $quote = DatabaseCompatibilityUtil::getQuote();
     $this->baseFromTableName = $tableName;
     $this->addTableCount($tableName);
 }

 /**
  * Any changes to the model must be re-cached.
  * @see RedBeanModel::save()
  */
 public function save($runValidation = true, array $attributeNames = null)
 {
     $saved = parent::save($runValidation, $attributeNames);
     if ($saved) {
         GeneralCache::cacheEntry('CustomFieldData' . $this->name, $this);
     }
     return $saved;
 }

 public function setUp()
 {
     parent::setUp();
     RedBeanModel::forgetAll();
     $this->setupServerUrl();
     if (!$this->isApiTestUrlConfigured()) {
         $this->markTestSkipped(Zurmo::t('ApiModule', 'API test url is not configured in perInstanceTest.php file.'));
     }
 }

 /**
  * Constructs a new RedBeanModels which is a collection of classes extending model.
  * The models are created lazily.
  * Models are only constructed with beans by the model. Beans are
  * never used by the application directly.
  */
 public function __construct(RedBean_OODBBean $bean, $modelClassName)
 {
     assert('is_string($modelClassName)');
     assert('$modelClassName != ""');
     $this->modelClassName = $modelClassName;
     $tableName = RedBeanModel::getTableName($modelClassName);
     $this->bean = $bean;
     $this->relatedBeansAndModels = array_values(R::related($this->bean, $tableName));
 }

 /**
  * Copy attributes from one model to another. If the attributes are relations, then only copy when it is a
  * HAS_ONE variant.  In the case that the relation is an OwnedModel, take special consideration for CurrencyValue
  * CustomField, and MultipleValuesCustomField models. If it is owned and not one of those 3, then it should just
  * copy the OwnedModel nonRelation attributes. An example of that would be Address or Email
  * @param RedBeanModel $model
  * @param RedBeanModel $copyToModel - model to copy attribute values from $model to
  */
 public static function copy(RedBeanModel $model, RedBeanModel $copyToModel)
 {
     $copyToModel->setIsCopied();
     foreach ($model->attributeNames() as $attributeName) {
         if ($attributeName == 'owner') {
             continue;
         }
         $isReadOnly = $model->isAttributeReadOnly($attributeName);
         if (!$model->isRelation($attributeName) && !$isReadOnly) {
             static::copyNonRelation($model, $attributeName, $copyToModel);
         } elseif ($model->isRelation($attributeName) && !$isReadOnly && $model->isRelationTypeAHasOneVariant($attributeName)) {
             static::copyRelation($model, $attributeName, $copyToModel);
         }
     }
     if ($model instanceof OwnedSecurableItem) {
         static::copyRelation($model, 'owner', $copyToModel);
     }
     static::resolveExplicitPermissions($model, $copyToModel);
 }

 /**
  * Make an array of message strings by RedBeanModel errors
  * @param array $errors RedBeanModel errors
  */
 public static function makeMessagesByModel(RedBeanModel $model)
 {
     $messages = array();
     foreach ($model->getErrors() as $attributeName => $errors) {
         foreach ($errors as $relationAttributeName => $errorOrRelatedError) {
             if (is_array($errorOrRelatedError)) {
                 $relationModelClassName = $model->getRelationModelClassName($attributeName);
                 foreach ($errorOrRelatedError as $relatedError) {
                     if ($relatedError != '') {
                         $messages[] = LabelUtil::makeModelAndAttributeNameCombinationLabel(get_class($model), $attributeName) . ' - ' . $relatedError;
                     }
                 }
             } elseif ($errorOrRelatedError != '') {
                 $messages[] = LabelUtil::makeModelAndAttributeNameCombinationLabel(get_class($model), $attributeName) . ' - ' . $errorOrRelatedError;
             }
         }
     }
     return $messages;
 }

 /**
  * @param SavedWorkflow $savedWorkflow
  * @param RedBeanModel $model
  * @return ByTimeWorkflowInQueue
  * @throws NotSupportedException
  */
 public static function resolveByWorkflowIdAndModel(SavedWorkflow $savedWorkflow, RedBeanModel $model)
 {
     $searchAttributeData = array();
     $searchAttributeData['clauses'] = array(1 => array('attributeName' => 'modelItem', 'operatorType' => 'equals', 'value' => $model->getClassId('Item')), 2 => array('attributeName' => 'savedWorkflow', 'operatorType' => 'equals', 'value' => $savedWorkflow->id), 3 => array('attributeName' => 'modelClassName', 'operatorType' => 'equals', 'value' => get_class($model)));
     $searchAttributeData['structure'] = '1 and 2 and 3';
     $joinTablesAdapter = new RedBeanModelJoinTablesQueryAdapter('ByTimeWorkflowInQueue');
     $where = RedBeanModelDataProvider::makeWhere('ByTimeWorkflowInQueue', $searchAttributeData, $joinTablesAdapter);
     $models = self::getSubset($joinTablesAdapter, null, null, $where, null);
     if (count($models) > 1) {
         throw new NotSupportedException();
     } elseif (count($models) == 1) {
         return $models[0];
     } else {
         $byTimeWorkflowInQueue = new ByTimeWorkflowInQueue();
         $byTimeWorkflowInQueue->modelClassName = get_class($model);
         $byTimeWorkflowInQueue->modelItem = $model;
         $byTimeWorkflowInQueue->savedWorkflow = $savedWorkflow;
         return $byTimeWorkflowInQueue;
     }
 }