find() public method

### Model.beforeFind event Each find() will trigger a Model.beforeFind event for all attached listeners. Any listener can set a valid result set using $query By default, $options will recognize the following keys: - fields - conditions - order - limit - offset - page - group - having - contain - join ### Usage Using the options array: $query = $articles->find('all', [ 'conditions' => ['published' => 1], 'limit' => 10, 'contain' => ['Users', 'Comments'] ]); Using the builder interface: $query = $articles->find() ->where(['published' => 1]) ->limit(10) ->contain(['Users', 'Comments']); ### Calling finders The find() method is the entry point for custom finder methods. You can invoke a finder by specifying the type: $query = $articles->find('published'); Would invoke the findPublished method.
public find ( $type = 'all', $options = [] ) : Query
return Query The query builder
コード例 #1
2
 /**
  * Helper generator for use with importTable().
  *
  * Yields a single new Entity instance approciate for $Table for each
  * of $records where the values are merged with $defaults.
  *
  * Will skip any records that fail to validate, dumping validation
  * errors to the console in the process.
  *
  * Used by imporTables().
  *
  * @param Cake\ORM\Table $Table A Table instance to save records into.
  * @param array $records An array of Entity records to save into the Table.
  * @param array $defaults Optional array of default field values to merge into each record.
  * @param array $options Optional array of newEntity() options to use.
  * @return void
  */
 public function entityGenerator(Table $Table, array $records, array $defaults = [], array $options = [])
 {
     $defaultOptions = ['validate' => true, 'accessibleFields' => ['*' => true]];
     $options = $options + $defaultOptions;
     $keyField = $Table->primaryKey();
     foreach ($records as $r) {
         $r = Hash::merge($defaults, $r);
         $id = !empty($r[$keyField]) ? $r[$keyField] : false;
         if ($id) {
             $entity = $Table->find()->where([$keyField => $id])->first();
             if ($entity) {
                 $entity = $Table->patchEntity($entity, $r, $options);
                 if (!$entity->dirty()) {
                     $this->verbose("<success>{$Table->alias()} ({$id}): No changes.</success>");
                     continue;
                 }
             } else {
                 $entity = $Table->newEntity($r, $options);
                 $entity->isNew(true);
             }
         } else {
             $entity = $Table->newEntity($r, $options);
         }
         $errors = $entity->errors();
         if ($errors) {
             $this->printValidationErrors($Table->alias(), $id, $errors);
             continue;
         }
         (yield $entity);
     }
 }
コード例 #2
1
 /**
  * test WHERE conditions against unary expression.
  *
  * @return void
  */
 public function testUnaryExpression()
 {
     $this->table->addColumn('user-birth-date', ['type' => 'date'], false);
     $first = $this->table->get(1);
     $first->set('user-birth-date', time());
     $this->table->save($first);
     $second = $this->table->find('all', ['eav' => true])->where(['user-birth-date IS' => null])->order(['id' => 'ASC'])->first();
     $this->assertTrue(!empty($second) && $second->get('id') == 2);
 }
コード例 #3
0
 /**
  * Method used to read from a database session.
  *
  * @param int|string $id The key of the value to read
  * @return mixed The value of the key or false if it does not exist
  */
 public function read($id)
 {
     $result = $this->_table->find('all')->select(['data'])->where([$this->_table->primaryKey() => $id])->hydrate(false)->first();
     if (empty($result)) {
         return false;
     }
     return $result['data'];
 }
コード例 #4
0
ファイル: CronController.php プロジェクト: Swader/nofw
 public function listCronsAction()
 {
     $cronSettings = $this->cronSettings->find()->hydrate(false)->toArray();
     if (empty($cronSettings)) {
         $cronSettings = ['output' => 'cron-all.log', 'recipients' => $this->site['sender']];
         $this->cronSettings->save($this->cronSettings->newEntity()->set($cronSettings));
     }
     echo $this->twig->render('cron/list.twig', ['crons' => $this->cronsTable->find()->hydrate(false)->toArray(), 'cronSettings' => $this->cronSettings->find()->hydrate(false)->toArray()[0]]);
 }
コード例 #5
0
 /**
  * Tests find('list') with hydrated records
  *
  * @return void
  */
 public function testFindListHydrated()
 {
     $table = new Table(['table' => 'users', 'connection' => $this->connection]);
     $table->displayField('username');
     $query = $table->find('list', ['fields' => ['id', 'username']])->order('id');
     $expected = [1 => 'mariano', 2 => 'nate', 3 => 'larry', 4 => 'garrett'];
     $this->assertSame($expected, $query->toArray());
     $query = $table->find('list', ['groupField' => 'odd'])->select(['id', 'username', 'odd' => new FunctionExpression('MOD', [new IdentifierExpression('id'), 2])])->hydrate(true)->order('id');
     $expected = [1 => [1 => 'mariano', 3 => 'larry'], 0 => [2 => 'nate', 4 => 'garrett']];
     $this->assertSame($expected, $query->toArray());
 }
コード例 #6
0
ファイル: ModuleComponent.php プロジェクト: Cheren/union
 /**
  * Setup modules for layout.
  *
  * @return void
  */
 private function __setForLayout()
 {
     $positions = $this->Theme->getThemePositions();
     $theme = Inflector::underscore(Configure::read('Theme.' . Theme::CLIENT_FRONT_END));
     foreach ($positions as $position) {
         $cacheKey = $theme . '_' . $position;
         $modules = $this->_table->find()->where(['position' => $position])->order(['ordering' => 'ASC'])->cache($cacheKey, 'positions')->toArray();
         if (!empty($modules)) {
             $this->_modulesForLayout[$position] = $modules;
         }
     }
     $this->_controller->set('module_for_layout', $this->_modulesForLayout);
 }
コード例 #7
0
ファイル: DatabaseSession.php プロジェクト: nrother/cakephp
 /**
  * Method used to read from a database session.
  *
  * @param int|string $id The key of the value to read
  * @return string The value of the key or empty if it does not exist
  */
 public function read($id)
 {
     $result = $this->_table->find('all')->select(['data'])->where([$this->_table->primaryKey() => $id])->hydrate(false)->first();
     if (empty($result)) {
         return '';
     }
     if (is_string($result['data'])) {
         return $result['data'];
     }
     $session = stream_get_contents($result['data']);
     if ($session === false) {
         return '';
     }
     return $session;
 }
コード例 #8
0
 protected function getFilteredPostsIds(array $identifiers, $mask, array $orX = [])
 {
     $orX = array_map(function ($value) {
         return str_replace('p.', 'Posts.', $value);
     }, $orX);
     $query = $this->Posts->find();
     $aclFilter = new CakephpOrmAclFilter($query);
     $aclFilter->setAclSchema($this->aclSchema);
     $aclFilter->apply('Posts', 'id', 'post-', $identifiers, $mask, $orX);
     $postsIds = [];
     foreach ($query->all() as $post) {
         $postsIds[] = $post->id;
     }
     return $postsIds;
 }
コード例 #9
0
 public function testFind()
 {
     $entities = [];
     foreach ($this->entityMap as $discriminator => $class) {
         $data = ['discriminator' => $discriminator];
         $entities[] = $this->table->newEntity($data);
     }
     $this->table->saveMany($entities);
     $found = $this->table->find()->toArray();
     $this->assertCount(6, $found);
     foreach ($found as $entity) {
         $class = $this->entityMap[$entity->discriminator];
         $this->assertInstanceOf($class, $entity);
     }
 }
コード例 #10
0
 /**
  * Builds a query for loading the passed list of entity objects along with the
  * associations specified in $contain.
  *
  * @param Cake\Collection\CollectionInterface $objects The original entitites
  * @param array $contain The associations to be loaded
  * @param Cake\ORM\Table $source The table to use for fetching the top level entities
  * @return Cake\ORM\Query
  */
 protected function _getQuery($objects, $contain, $source)
 {
     $primaryKey = $source->primaryKey();
     $method = is_string($primaryKey) ? 'get' : 'extract';
     $keys = $objects->map(function ($entity) use($primaryKey, $method) {
         return $entity->{$method}($primaryKey);
     });
     $query = $source->find()->select((array) $primaryKey)->where(function ($exp, $q) use($primaryKey, $keys, $source) {
         if (is_array($primaryKey) && count($primaryKey) === 1) {
             $primaryKey = current($primaryKey);
         }
         if (is_string($primaryKey)) {
             return $exp->in($source->aliasField($primaryKey), $keys->toList());
         }
         $types = array_intersect_key($q->defaultTypes(), array_flip($primaryKey));
         $primaryKey = array_map([$source, 'aliasField'], $primaryKey);
         return new TupleComparison($primaryKey, $keys->toList(), $types, 'IN');
     })->contain($contain);
     foreach ($query->eagerLoader()->attachableAssociations($source) as $loadable) {
         $config = $loadable->config();
         $config['includeFields'] = true;
         $loadable->config($config);
     }
     return $query;
 }
コード例 #11
0
ファイル: TranslateBehavior.php プロジェクト: wepbunny/cake2
 /**
  * Modifies the entity before it is saved so that translated fields are persisted
  * in the database too.
  *
  * @param \Cake\Event\Event $event The beforeSave event that was fired
  * @param \Cake\Datasource\EntityInterface $entity The entity that is going to be saved
  * @param \ArrayObject $options the options passed to the save method
  * @return void
  */
 public function beforeSave(Event $event, EntityInterface $entity, ArrayObject $options)
 {
     $locale = $entity->get('_locale') ?: $this->locale();
     $newOptions = [$this->_translationTable->alias() => ['validate' => false]];
     $options['associated'] = $newOptions + $options['associated'];
     $this->_bundleTranslatedFields($entity);
     $bundled = $entity->get('_i18n') ?: [];
     if ($locale === $this->config('defaultLocale')) {
         return;
     }
     $values = $entity->extract($this->_config['fields'], true);
     $fields = array_keys($values);
     $primaryKey = (array) $this->_table->primaryKey();
     $key = $entity->get(current($primaryKey));
     $model = $this->_config['referenceName'];
     $preexistent = $this->_translationTable->find()->select(['id', 'field'])->where(['field IN' => $fields, 'locale' => $locale, 'foreign_key' => $key, 'model' => $model])->bufferResults(false)->indexBy('field');
     $modified = [];
     foreach ($preexistent as $field => $translation) {
         $translation->set('content', $values[$field]);
         $modified[$field] = $translation;
     }
     $new = array_diff_key($values, $modified);
     foreach ($new as $field => $content) {
         $new[$field] = new Entity(compact('locale', 'field', 'content', 'model'), ['useSetters' => false, 'markNew' => true]);
     }
     $entity->set('_i18n', array_merge($bundled, array_values($modified + $new)));
     $entity->set('_locale', $locale, ['setter' => false]);
     $entity->dirty('_locale', false);
     foreach ($fields as $field) {
         $entity->dirty($field, false);
     }
 }
コード例 #12
0
 /**
  * ResetSlugs method.
  *
  * Regenerate all slugs. On large dbs this can take more than 30 seconds - a time
  * limit is set to allow a minimum 100 updates per second as a preventative measure.
  *
  * Note that you should use the Reset behavior if you need additional functionality such
  * as callbacks or timeouts.
  *
  * @param array $params
  * @return bool Success
  */
 public function resetSlugs($params = [])
 {
     if (!$this->_table->hasField($this->_config['field'])) {
         throw new Exception('Table does not have field ' . $this->_config['field']);
     }
     $defaults = ['page' => 1, 'limit' => 100, 'fields' => array_merge([$this->_table->primaryKey()], $this->_config['label']), 'order' => $this->_table->displayField() . ' ASC', 'conditions' => $this->_config['scope'], 'overwrite' => true];
     $params = array_merge($defaults, $params);
     $count = $this->_table->find('all', compact('conditions'))->count();
     $max = ini_get('max_execution_time');
     if ($max) {
         set_time_limit(max($max, $count / 100));
     }
     $this->_table->behaviors()->Slugged->config($params, null, false);
     while ($records = $this->_table->find('all', $params)->toArray()) {
         foreach ($records as $record) {
             $record->isNew(true);
             $options = ['validate' => true, 'fieldList' => array_merge([$this->_table->primaryKey(), $this->_config['field']], $this->_config['label'])];
             if (!$this->_table->save($record, $options)) {
                 throw new Exception(print_r($this->_table->errors(), true));
             }
         }
         $params['page']++;
     }
     return true;
 }
コード例 #13
0
 /**
  * TreeHelperTest::testGenerateProductive()
  *
  * @return void
  */
 public function testGenerateProductive()
 {
     $tree = $this->Table->find('threaded')->toArray();
     $output = $this->Tree->generate($tree, ['indent' => false]);
     $expected = '<ul><li>One<ul><li>One-SubA</li></ul></li><li>Two<ul><li>Two-SubA<ul><li>Two-SubA-1<ul><li>Two-SubA-1-1</li></ul></li></ul></li></ul></li><li>Three</li><li>Four<ul><li>Four-SubA</li></ul></li></ul>';
     $this->assertTextEquals($expected, $output);
 }
コード例 #14
0
ファイル: BasicCRUD.php プロジェクト: bostontrader/acctwerx
 public function testGET_index()
 {
     // 1. Submit submit request, examine response, observe no redirect, and parse the response.
     $book_id = FixtureConstants::bookTypical;
     $book = $this->Books->get($book_id);
     $this->get('/books/' . $book_id . '/transactions');
     $this->assertResponseCode(200);
     $this->assertNoRedirect();
     $dom = new \DomDocument();
     $dom->loadHTML($this->_response->body());
     $xpath = new \DomXPath($dom);
     // 2. Isolate the content produced by this controller method (excluding the layout.)
     $content_node = $this->getTheOnlyOne($xpath, "//div[@id='TransactionsIndex']");
     // 3. Count the A tags.
     $unknownATagCnt = $xpath->query(".//a", $content_node)->length;
     // 4. Look for the create new transaction link
     $this->getTheOnlyOne($xpath, "//a[@id='TransactionNewform']", $content_node);
     $unknownATagCnt--;
     // 5. Ensure that there is a suitably named table to display the results.
     $table_node = $this->getTheOnlyOne($xpath, "//table[@id='TransactionsTable']", $content_node);
     // 6. Now inspect the caption of the table.
     $this->assertContains($book['title'], $this->getTheOnlyOne($xpath, "caption", $table_node)->textContent);
     // 7. Ensure that said table's thead element contains the correct
     //    headings, in the correct order, and nothing else.
     $column_header_nodes = $xpath->query("thead/tr/th", $table_node);
     $this->assertEquals($column_header_nodes->length, 3);
     // no other columns
     $this->getTheOnlyOne($xpath, "thead/tr/th[1][@id='note']", $table_node);
     $this->getTheOnlyOne($xpath, "thead/tr/th[2][@id='tran_datetime']", $table_node);
     $this->getTheOnlyOne($xpath, "thead/tr/th[3][@id='actions']", $table_node);
     // 8. Ensure that the tbody section has the correct quantity of rows.
     $dbRecords = $this->Transactions->find()->where(['book_id' => $book_id])->order(['tran_datetime' => 'desc']);
     $tbody_nodes = $xpath->query("tbody/tr", $table_node);
     $this->assertTrue($tbody_nodes->length == $dbRecords->count());
     // 9. Ensure that the values displayed in each row, match the values from
     //    the fixture.  The values should be presented in a particular order
     //    with nothing else thereafter.
     $iterator = new \MultipleIterator();
     $iterator->attachIterator(new \ArrayIterator($dbRecords->execute()->fetchAll('assoc')));
     $iterator->attachIterator(new \ArrayIterator(iterator_to_array($tbody_nodes)));
     foreach ($iterator as $values) {
         $fixtureRecord = $values[0];
         $row_node = $values[1];
         $column_nodes = $xpath->query("td", $row_node);
         $this->assertEquals($fixtureRecord['Transactions__note'], $column_nodes->item(0)->textContent);
         //$this->assertEquals($fixtureRecord['Transactions__datetime'],  $column_nodes->item(1)->textContent);
         // 9.1 Now examine the action links
         $action_nodes = $xpath->query("a", $column_nodes->item(2));
         $this->assertTrue($action_nodes->length == 2);
         $this->getTheOnlyOne($xpath, "a[@name='TransactionView']", $column_nodes->item(2));
         $unknownATagCnt--;
         $this->getTheOnlyOne($xpath, "a[@name='TransactionEditform']", $column_nodes->item(2));
         $unknownATagCnt--;
         // 9.9 No other columns
         $this->assertEquals($column_nodes->length, $column_header_nodes->length);
     }
     // 10. Ensure that all the <A> tags have been accounted for
     $this->assertEquals(0, $unknownATagCnt);
 }
コード例 #15
0
 /**
  * Overload find to cause issues.
  *
  * @param string $type Find type
  * @param array $options find options
  * @return object
  */
 public function find($type = 'all', $options = [])
 {
     if (empty($options['conditions'])) {
         $options['conditions'] = [];
     }
     $options['conditions'] = array_merge($options['conditions'], ['Comments.published' => 'Y']);
     return parent::find($type, $options);
 }
コード例 #16
0
ファイル: NumbersTable.php プロジェクト: midorikocak/numbers
 public function find($type = 'all', $options = [])
 {
     $data = parent::find($type, $options);
     return $data->formatResults(function ($r) {
         return $r->map(function ($r) {
             $r['number'] = $this->showNumber($r['number']);
             return $r;
         });
     });
 }
コード例 #17
0
 /**
  * Returns the maximum index value in the table.
  *
  * @return int
  */
 protected function _getMax()
 {
     $config = $this->config();
     $field = $config['right'];
     $edge = $this->_scope($this->_table->find())->select([$field])->order([$field => 'DESC'])->first();
     if (empty($edge->{$field})) {
         return 0;
     }
     return $edge->{$field};
 }
コード例 #18
0
 /**
  * Implementation of afterDelete event for images table, handles deleting image files.
  *
  * @param Event $event Event object.
  * @param Entity $entity Entity object.
  * @param \ArrayObject $options Options array.
  * @return void
  */
 public function imageAfterDelete(Event $event, Entity $entity, \ArrayObject $options)
 {
     $shared = $this->_imagesTable->find()->where(['foreign_key !=' => $entity->foreign_key, 'model' => $entity->model, 'filename' => $entity->filename]);
     if (!$shared->count()) {
         $basePath = $this->basePath();
         (new File($basePath . DS . $entity->filename))->delete();
         foreach ($this->config('presets') as $preset => $options) {
             (new File($basePath . DS . $preset . DS . $entity->filename))->delete();
         }
     }
 }
コード例 #19
0
ファイル: TranslateBehavior.php プロジェクト: cakephp/orm
 /**
  * Modifies the entity before it is saved so that translated fields are persisted
  * in the database too.
  *
  * @param \Cake\Event\Event $event The beforeSave event that was fired
  * @param \Cake\Datasource\EntityInterface $entity The entity that is going to be saved
  * @param \ArrayObject $options the options passed to the save method
  * @return void
  */
 public function beforeSave(Event $event, EntityInterface $entity, ArrayObject $options)
 {
     $locale = $entity->get('_locale') ?: $this->locale();
     $newOptions = [$this->_translationTable->alias() => ['validate' => false]];
     $options['associated'] = $newOptions + $options['associated'];
     $this->_bundleTranslatedFields($entity);
     $bundled = $entity->get('_i18n') ?: [];
     $noBundled = count($bundled) === 0;
     // No additional translation records need to be saved,
     // as the entity is in the default locale.
     if ($noBundled && $locale === $this->config('defaultLocale')) {
         return;
     }
     $values = $entity->extract($this->_config['fields'], true);
     $fields = array_keys($values);
     $noFields = empty($fields);
     // If there are no fields and no bundled translations, or both fields
     // in the default locale and bundled translations we can
     // skip the remaining logic as its not necessary.
     if ($noFields && $noBundled || $fields && $bundled) {
         return;
     }
     $primaryKey = (array) $this->_table->primaryKey();
     $key = $entity->get(current($primaryKey));
     // When we have no key and bundled translations, we
     // need to mark the entity dirty so the root
     // entity persists.
     if ($noFields && $bundled && !$key) {
         foreach ($this->_config['fields'] as $field) {
             $entity->dirty($field, true);
         }
         return;
     }
     if ($noFields) {
         return;
     }
     $model = $this->_config['referenceName'];
     $preexistent = $this->_translationTable->find()->select(['id', 'field'])->where(['field IN' => $fields, 'locale' => $locale, 'foreign_key' => $key, 'model' => $model])->bufferResults(false)->indexBy('field');
     $modified = [];
     foreach ($preexistent as $field => $translation) {
         $translation->set('content', $values[$field]);
         $modified[$field] = $translation;
     }
     $new = array_diff_key($values, $modified);
     foreach ($new as $field => $content) {
         $new[$field] = new Entity(compact('locale', 'field', 'content', 'model'), ['useSetters' => false, 'markNew' => true]);
     }
     $entity->set('_i18n', array_merge($bundled, array_values($modified + $new)));
     $entity->set('_locale', $locale, ['setter' => false]);
     $entity->dirty('_locale', false);
     foreach ($fields as $field) {
         $entity->dirty($field, false);
     }
 }
コード例 #20
0
 /**
  * Find or create new draft database entry and return entity ID
  * 
  * @param \Cake\ORM\Table $table      Table instance
  * @param array|null      $conditions Find conditions
  *
  * @return int             $id         Draft Id
  */
 public function getDraftId(Table $table, $conditions = [])
 {
     $conditions = array_merge($this->config[$table->alias()]['conditions'], $conditions);
     $result = $table->find()->select(['id' => $table->primaryKey()])->andWhere($conditions)->first();
     if ($result) {
         return $result->id;
     } else {
         $entity = $table->newEntity($conditions, ['validate' => false]);
         $entity = $table->save($entity);
         return $entity->id;
     }
 }
コード例 #21
0
ファイル: Marshaller.php プロジェクト: rlugojr/cakephp
 /**
  * Merges each of the elements from `$data` into each of the entities in `$entities`
  * and recursively does the same for each of the association names passed in
  * `$options`. When merging associations, if an entity is not present in the parent
  * entity for a given association, a new one will be created.
  *
  * Records in `$data` are matched against the entities using the primary key
  * column. Entries in `$entities` that cannot be matched to any record in
  * `$data` will be discarded. Records in `$data` that could not be matched will
  * be marshalled as a new entity.
  *
  * When merging HasMany or BelongsToMany associations, all the entities in the
  * `$data` array will appear, those that can be matched by primary key will get
  * the data merged, but those that cannot, will be discarded.
  *
  * ### Options:
  *
  * - validate: Whether or not to validate data before hydrating the entities. Can
  *   also be set to a string to use a specific validator. Defaults to true/default.
  * - associated: Associations listed here will be marshalled as well.
  * - fieldList: A whitelist of fields to be assigned to the entity. If not present,
  *   the accessible fields list in the entity will be used.
  * - accessibleFields: A list of fields to allow or deny in entity accessible fields.
  *
  * @param array|\Traversable $entities the entities that will get the
  *   data merged in
  * @param array $data list of arrays to be merged into the entities
  * @param array $options List of options.
  * @return array
  */
 public function mergeMany($entities, array $data, array $options = [])
 {
     $primary = (array) $this->_table->primaryKey();
     $indexed = (new Collection($data))->groupBy(function ($el) use($primary) {
         $keys = [];
         foreach ($primary as $key) {
             $keys[] = isset($el[$key]) ? $el[$key] : '';
         }
         return implode(';', $keys);
     })->map(function ($element, $key) {
         return $key === '' ? $element : $element[0];
     })->toArray();
     $new = isset($indexed[null]) ? $indexed[null] : [];
     unset($indexed[null]);
     $output = [];
     foreach ($entities as $entity) {
         if (!$entity instanceof EntityInterface) {
             continue;
         }
         $key = implode(';', $entity->extract($primary));
         if ($key === null || !isset($indexed[$key])) {
             continue;
         }
         $output[] = $this->merge($entity, $indexed[$key], $options);
         unset($indexed[$key]);
     }
     $maybeExistentQuery = (new Collection($indexed))->map(function ($data, $key) {
         return explode(';', $key);
     })->filter(function ($keys) use($primary) {
         return count(array_filter($keys, 'strlen')) === count($primary);
     })->reduce(function ($query, $keys) use($primary) {
         $fields = array_map([$this->_table, 'aliasField'], $primary);
         return $query->orWhere($query->newExpr()->and_(array_combine($fields, $keys)));
     }, $this->_table->find());
     if (!empty($indexed) && count($maybeExistentQuery->clause('where'))) {
         foreach ($maybeExistentQuery as $entity) {
             $key = implode(';', $entity->extract($primary));
             if (isset($indexed[$key])) {
                 $output[] = $this->merge($entity, $indexed[$key], $options);
                 unset($indexed[$key]);
             }
         }
     }
     foreach ((new Collection($indexed))->append($new) as $value) {
         if (!is_array($value)) {
             continue;
         }
         $output[] = $this->one($value, $options);
     }
     return $output;
 }
コード例 #22
0
 /**
  * testBeforeFind
  *
  * @return void
  * @access public
  */
 public function testBeforeFind()
 {
     $condicoes = ['nome' => '1.000,00', 'valor' => '1.500,03'];
     $consulta = $this->Produtos->find('all')->where($condicoes);
     $consulta->all();
     $condicoesTratadas = [];
     $todosCampos = [];
     /**
      * @var Query $consulta
      */
     $consulta->clause("where")->traverse(function ($comparison) use(&$condicoesTratadas, &$todosCampos) {
         /**
          * @var Comparison $comparison
          */
         if (isset($comparison)) {
             if ($this->Produtos->schema()->columnType($comparison->getField()) === "float") {
                 $condicoesTratadas[$comparison->getField()] = $comparison->getValue();
             }
             $todosCampos[$comparison->getField()] = $comparison->getValue();
         }
     });
     $this->assertEquals("1.000,00", $todosCampos["nome"]);
     $this->assertEquals("1500.03", $condicoesTratadas["valor"]);
 }
コード例 #23
0
 /**
  * Finds all the categories
  *
  * @param Table $extensionsTable The extensions database table
  * @return array The categories and all their settings
  */
 protected function _getSettings(Table $extensionsTable)
 {
     $extensions = $extensionsTable->find('all', ['fields' => ['Extensions.id', 'Extensions.short_name'], 'contain' => ['Categories' => ['fields' => ['Categories.id', 'Categories.extension_id', 'Categories.short_name', 'Categories.enabled'], 'Settings' => ['fields' => ['Settings.short_name', 'Settings.category_id', 'Settings.default_value'], 'SettingValues' => ['fields' => ['SettingValues.value']]]]]])->all()->toArray();
     $extensions = Hash::combine($extensions, '{n}.short_name', '{n}');
     foreach ($extensions as $extension) {
         $extension->categories = Hash::combine($extension->categories, '{n}.short_name', '{n}');
         foreach ($extension->categories as $category) {
             $category->settings = Hash::combine($category->settings, '{n}.short_name', '{n}');
             foreach ($category->settings as $setting) {
                 if (isset($setting->setting_value->value)) {
                     $setting->setting_value = $setting->setting_value->value;
                 }
             }
         }
     }
     return $extensions;
 }
コード例 #24
0
 /**
  * Retrieve and return associated record Entity, by primary key value.
  * If the record has been trashed - query will return NULL.
  *
  * @param  \Cake\ORM\Table $table Table instance
  * @param  string          $value Primary key value
  * @return object
  */
 protected function _getAssociatedRecord(Table $table, $value)
 {
     $options = ['conditions' => [$table->primaryKey() => $value], 'limit' => 1];
     // try to fetch with trashed if finder method exists, otherwise fallback to find all
     try {
         $query = $table->find('withTrashed', $options);
     } catch (BadMethodCallException $e) {
         $query = $table->find('all', $options);
     }
     return $query->first();
 }
コード例 #25
0
 /**
  * Tests find('list') with composite keys
  *
  * @return void
  */
 public function testFindListCompositeKeys()
 {
     $table = new Table(['table' => 'site_authors', 'connection' => $this->connection]);
     $table->displayField('name');
     $query = $table->find('list')->hydrate(false)->order('id');
     $expected = ['1;1' => 'mark', '2;2' => 'juan', '3;2' => 'jose', '4;1' => 'andy'];
     $this->assertEquals($expected, $query->toArray());
     $table->displayField(['name', 'site_id']);
     $query = $table->find('list')->hydrate(false)->order('id');
     $expected = ['1;1' => 'mark;1', '2;2' => 'juan;2', '3;2' => 'jose;2', '4;1' => 'andy;1'];
     $this->assertEquals($expected, $query->toArray());
     $query = $table->find('list', ['groupField' => ['site_id', 'site_id']])->hydrate(false)->order('id');
     $expected = ['1;1' => ['1;1' => 'mark;1', '4;1' => 'andy;1'], '2;2' => ['2;2' => 'juan;2', '3;2' => 'jose;2']];
     $this->assertEquals($expected, $query->toArray());
 }
コード例 #26
0
 /**
  * Checks whether a variable is an array
  *
  * @param Table $table Instance of a table
  * @param string $methodName Name of method
  * @param string $findMethod Find method to use
  * @param array $findOptions array of options to pass to the table method
  * @return mixed
  **/
 public function getData(Table $Table, $methodName, $findMethod, $findOptions)
 {
     if (empty($methodName)) {
         $methodName = 'find';
     }
     if (empty($findMethod)) {
         $findMethod = 'first';
     }
     if ($methodName == 'find') {
         return $Table->find($findMethod, $findOptions);
     }
     return $Table->{$methodName}($findOptions);
 }
コード例 #27
0
 /**
  * Login and submit a POST request to a $url that is expected to add a given record.
  * Retrieve the record with the highest id, which we hope is the new record we just
  * added, and return that to the caller.
  *
  * @param int $user_id The user to login as.
  * @param String $url The url to send the request to.
  * @param array $newRecord
  * @param String $redirect_url The url to redirect to, after the deletion.
  * @param \Cake\ORM\Table $table The table to receive the new record.
  * @param boolean $redirect2_new_id By default, redirection should go to $redirect_url. However,
  * if $redirect2_new_id=true, then redirect to $redirect_url/$redirect2_new_id.
  *
  * @return \Cake\ORM\Entity The newly added record, as read from the db.
  */
 protected function genericPOSTAddProlog($user_id, $url, $newRecord, $redirect_url, $table, $redirect2_new_id = false)
 {
     //$this->fakeLogin($user_id);
     $this->post($url, $newRecord);
     // Now retrieve the newly written record.
     $fromDbRecord = $table->find('all')->order(['id' => 'DESC'])->first();
     $this->assertResponseCode(302);
     if ($redirect2_new_id) {
         $this->assertRedirect("{$redirect_url}/{$fromDbRecord->id}");
     } else {
         $this->assertRedirect($redirect_url);
     }
     return $fromDbRecord;
 }
コード例 #28
0
 /**
  * Test find('list') with value field from associated table
  *
  * @return void
  */
 public function testFindListWithAssociatedTable()
 {
     $articles = new Table(['table' => 'articles', 'connection' => $this->connection]);
     $articles->belongsTo('Authors');
     $query = $articles->find('list', ['valueField' => 'author.name'])->contain(['Authors'])->order('articles.id');
     $this->assertEmpty($query->clause('select'));
     $expected = [1 => 'mariano', 2 => 'larry', 3 => 'mariano'];
     $this->assertSame($expected, $query->toArray());
 }
コード例 #29
0
 /**
  * Processes the records.
  *
  * @param \Cake\ORM\Table $table
  * @param int $chunkCount
  * @param int $chunkSize
  * @return void
  */
 protected function _process(Table $table, $chunkCount, $chunkSize)
 {
     $query = $table->find();
     if ($table->hasFinder('purifier')) {
         $query->find('purifier');
     }
     $fields = explode(',', $this->param('fields'));
     $fields[] = $table->primaryKey();
     $results = $query->select($fields)->offset($chunkCount)->limit($chunkSize)->orderDesc($table->aliasField($table->primaryKey()))->all();
     if (empty($results)) {
         return;
     }
     foreach ($results as $result) {
         try {
             $table->save($result);
             $chunkCount++;
         } catch (\Exception $e) {
             $this->error($e->getMessage());
         }
     }
 }
コード例 #30
0
ファイル: TreeBehaviorTest.php プロジェクト: Rabp9/test-psi2
 /**
  * Assert MPTT values
  *
  * Custom assert method to make identifying the differences between expected
  * and actual db state easier to identify.
  *
  * @param array $expected tree state to be expected
  * @param \Cake\ORM\Table $table Table instance
  * @param \Cake\ORM\Query $query Optional query object
  * @return void
  */
 public function assertMpttValues($expected, $table, $query = null)
 {
     $query = $query ?: $table->find();
     $primaryKey = $table->primaryKey();
     if (is_array($primaryKey)) {
         $primaryKey = $primaryKey[0];
     }
     $displayField = $table->displayField();
     $options = ['valuePath' => function ($item, $key, $iterator) use($primaryKey, $displayField) {
         return sprintf('%s:%s - %s:%s', str_pad($item->lft, 2, ' ', STR_PAD_LEFT), str_pad($item->rght, 2, ' ', STR_PAD_LEFT), str_pad($item->{$primaryKey}, 2, ' ', STR_PAD_LEFT), $item->{$displayField});
     }];
     $result = array_values($query->find('treeList', $options)->toArray());
     if (count($result) === count($expected)) {
         $subExpected = array_diff($expected, $result);
         if ($subExpected) {
             $subResult = array_intersect_key($result, $subExpected);
             $this->assertSame($subExpected, $subResult, 'Differences in the tree were found (lft:rght id:display-name)');
         }
     }
     $this->assertSame($expected, $result, 'The tree is not the same (lft:rght id:display-name)');
 }