예제 #1
0
 /**
  * Checks if the given menu link should be marked as active.
  *
  * If `$item->activation` is a callable function it will be used to determinate
  * if the link should be active or not, returning true from callable indicates
  * link should be active, false indicates it should not be marked as active.
  * Callable receives current request object as first argument and $item as second.
  *
  * `$item->url` property MUST exists if "activation" is not a callable, and can
  * be either:
  *
  * - A string representing an external or internal URL (all internal links must
  *   starts with "/"). e.g. `/user/login`
  *
  * - An array compatible with \Cake\Routing\Router::url(). e.g. `['controller'
  *   => 'users', 'action' => 'login']`
  *
  * Both examples are equivalent.
  *
  * @param \Cake\Datasource\EntityInterface $item A menu's item
  * @return bool
  */
 public function isActive(EntityInterface $item)
 {
     if ($item->has('activation') && is_callable($item->get('activation'))) {
         $callable = $item->get('activation');
         return $callable($this->_View->request, $item);
     }
     $itemUrl = $this->sanitize($item->get('url'));
     if (!str_starts_with($itemUrl, '/')) {
         return false;
     }
     switch ($item->get('activation')) {
         case 'any':
             return $this->_requestMatches($item->get('active'));
         case 'none':
             return !$this->_requestMatches($item->get('active'));
         case 'php':
             return php_eval($item->get('active'), ['view', &$this->_View, 'item', &$item]) === true;
         case 'auto':
         default:
             static $requestUri = null;
             static $requestUrl = null;
             if ($requestUri === null) {
                 $requestUri = urldecode(env('REQUEST_URI'));
                 $requestUrl = str_replace('//', '/', '/' . urldecode($this->_View->request->url) . '/');
             }
             $isInternal = $itemUrl !== '/' && str_ends_with($itemUrl, str_replace_once($this->baseUrl(), '', $requestUri));
             $isIndex = $itemUrl === '/' && $this->_View->request->isHome();
             $isExact = str_replace('//', '/', "{$itemUrl}/") === $requestUrl || $itemUrl == $requestUri;
             if ($this->config('breadcrumbGuessing')) {
                 return $isInternal || $isIndex || $isExact || in_array($itemUrl, $this->_crumbs());
             }
             return $isInternal || $isIndex || $isExact;
     }
 }
예제 #2
0
 /**
  * Perform the delete operation.
  *
  * Will soft delete the entity provided. Will remove rows from any
  * dependent associations, and clear out join tables for BelongsToMany associations.
  *
  * @param \Cake\DataSource\EntityInterface $entity The entity to soft delete.
  * @param \ArrayObject $options The options for the delete.
  * @throws \InvalidArgumentException if there are no primary key values of the
  * passed entity
  * @return bool success
  */
 protected function _processDelete($entity, $options)
 {
     if ($entity->isNew()) {
         return false;
     }
     $primaryKey = (array) $this->primaryKey();
     if (!$entity->has($primaryKey)) {
         $msg = 'Deleting requires all primary key values.';
         throw new \InvalidArgumentException($msg);
     }
     if ($options['checkRules'] && !$this->checkRules($entity, RulesChecker::DELETE, $options)) {
         return false;
     }
     $event = $this->dispatchEvent('Model.beforeDelete', ['entity' => $entity, 'options' => $options]);
     if ($event->isStopped()) {
         return $event->result;
     }
     $this->_associations->cascadeDelete($entity, ['_primary' => false] + $options->getArrayCopy());
     $query = $this->query();
     $conditions = (array) $entity->extract($primaryKey);
     $statement = $query->update()->set([$this->getSoftDeleteField() => 0])->where($conditions)->execute();
     $success = $statement->rowCount() > 0;
     if (!$success) {
         return $success;
     }
     $this->dispatchEvent('Model.afterDelete', ['entity' => $entity, 'options' => $options]);
     return $success;
 }
예제 #3
0
 /**
  * Performs the existence check
  *
  * @param \Cake\Datasource\EntityInterface $entity The entity from where to extract the fields
  * @param array $options Options passed to the check,
  * where the `repository` key is required.
  * @throws \RuntimeException When the rule refers to an undefined association.
  * @return bool
  */
 public function __invoke(EntityInterface $entity, array $options)
 {
     if (is_string($this->_repository)) {
         $alias = $this->_repository;
         $this->_repository = $options['repository']->association($alias);
         if (empty($this->_repository)) {
             throw new RuntimeException(sprintf("ExistsIn rule for '%s' is invalid. The '%s' association is not defined.", implode(', ', $this->_fields), $alias));
         }
     }
     $source = $target = $this->_repository;
     if (!empty($options['repository'])) {
         $source = $options['repository'];
     }
     if ($source instanceof Association) {
         $source = $source->source();
     }
     if ($target instanceof Association) {
         $bindingKey = (array) $target->bindingKey();
         $target = $target->target();
     } else {
         $bindingKey = (array) $target->primaryKey();
     }
     if (!empty($options['_sourceTable']) && $target === $options['_sourceTable']) {
         return true;
     }
     if (!$entity->extract($this->_fields, true)) {
         return true;
     }
     if ($this->_fieldsAreNull($entity, $source)) {
         return true;
     }
     $primary = array_map([$target, 'aliasField'], $bindingKey);
     $conditions = array_combine($primary, $entity->extract($this->_fields));
     return $target->exists($conditions);
 }
예제 #4
0
 /**
  * Performs the existence check
  *
  * @param \Cake\Datasource\EntityInterface $entity The entity from where to extract the fields
  * @param array $options Options passed to the check,
  * where the `repository` key is required.
  * @return bool
  */
 public function __invoke(EntityInterface $entity, array $options)
 {
     if (is_string($this->_repository)) {
         $this->_repository = $options['repository']->association($this->_repository);
     }
     $source = !empty($options['repository']) ? $options['repository'] : $this->_repository;
     $source = $source instanceof Association ? $source->source() : $source;
     $target = $this->_repository;
     if ($target instanceof Association) {
         $bindingKey = (array) $target->bindingKey();
         $target = $this->_repository->target();
     } else {
         $bindingKey = (array) $target->primaryKey();
     }
     if (!empty($options['_sourceTable']) && $target === $options['_sourceTable']) {
         return true;
     }
     if (!$entity->extract($this->_fields, true)) {
         return true;
     }
     $nulls = 0;
     $schema = $source->schema();
     foreach ($this->_fields as $field) {
         if ($schema->column($field) && $schema->isNullable($field) && $entity->get($field) === null) {
             $nulls++;
         }
     }
     if ($nulls === count($this->_fields)) {
         return true;
     }
     $primary = array_map([$this->_repository, 'aliasField'], $bindingKey);
     $conditions = array_combine($primary, $entity->extract($this->_fields));
     return $this->_repository->exists($conditions);
 }
예제 #5
0
 /**
  * Performs the existence check
  *
  * @param \Cake\Datasource\EntityInterface $entity The entity from where to extract the fields
  * @param array $options Options passed to the check,
  * where the `repository` key is required.
  * @return bool
  */
 public function __invoke(EntityInterface $entity, array $options)
 {
     if (is_string($this->_repository)) {
         $this->_repository = $options['repository']->association($this->_repository);
     }
     if (!empty($options['_sourceTable'])) {
         $source = $this->_repository instanceof Association ? $this->_repository->target() : $this->_repository;
         if ($source === $options['_sourceTable']) {
             return true;
         }
     }
     if (!$entity->extract($this->_fields, true)) {
         return true;
     }
     $nulls = 0;
     $schema = $this->_repository->schema();
     foreach ($this->_fields as $field) {
         if ($schema->isNullable($field) && $entity->get($field) === null) {
             $nulls++;
         }
     }
     if ($nulls === count($this->_fields)) {
         return true;
     }
     $alias = $this->_repository->alias();
     $primary = array_map(function ($key) use($alias) {
         return "{$alias}.{$key}";
     }, (array) $this->_repository->primaryKey());
     $conditions = array_combine($primary, $entity->extract($this->_fields));
     return $this->_repository->exists($conditions);
 }
 /**
  * afterSave Event
  *
  * @param Event $event Event
  * @param EntityInterface $entity Entity to be saved
  * @return void
  */
 public function afterSave(Event $event, EntityInterface $entity)
 {
     $uploads = $entity->get($this->config('formFieldName'));
     if (!empty($uploads)) {
         $this->Attachments->addUploads($entity, $uploads);
     }
 }
예제 #7
0
 /**
  * Send the reset password email to the user
  *
  * @param EntityInterface $user User entity
  * @param string $template string, note the first_name of the user will be prepended if exists
  *
  * @return array email send result
  */
 protected function resetPassword(EntityInterface $user, $template = 'CakeDC/Users.reset_password')
 {
     $firstName = isset($user['first_name']) ? $user['first_name'] . ', ' : '';
     $subject = __d('Users', '{0}Your reset password link', $firstName);
     $user->hiddenProperties(['password', 'token_expires', 'api_token']);
     $this->to($user['email'])->subject($subject)->viewVars($user->toArray())->template($template);
 }
예제 #8
0
 public function beforeSave(Event $event, EntityInterface $entity)
 {
     if ($entity === null) {
         return true;
     }
     $isNew = $entity->isNew();
     $fields = $this->config('fields');
     $ip = self::$_request->clientIp();
     foreach ($fields as $field => $when) {
         $when = strtolower($when);
         if (!in_array($when, ['always', 'new'])) {
             throw new UnexpectedValueException(sprintf('"When" should be one of "always", "new". The passed value "%s" is invalid', $when));
         }
         switch ($when) {
             case 'always':
                 $entity->set($field, $ip);
                 continue;
                 break;
             case 'new':
                 if ($isNew) {
                     $entity->set($field, $ip);
                     continue;
                 }
                 break;
         }
     }
     return true;
 }
예제 #9
0
 public function beforeSave(Event $event, EntityInterface $entity)
 {
     $config = $this->config();
     $new = $entity->isNew();
     if ($config['when'] === 'always' || $config['when'] === 'new' && $new || $config['when'] === 'existing' && !$new) {
         $this->slug($entity);
     }
 }
예제 #10
0
 /**
  * Callback before save entity.
  *
  * @param Event $event
  * @param EntityInterface $entity
  * @param \ArrayObject $options
  * @return bool
  */
 public function beforeSave(Event $event, EntityInterface $entity, \ArrayObject $options)
 {
     //  Hack for test fieldToggle.
     if ($entity->get('id') == 4) {
         return false;
     }
     return true;
 }
 /**
  * Render a multi select with all available tags of entity and the tags of attachment preselected
  *
  * @param  EntityInterface                    $entity     the entity to get all allowed tags from
  * @param  Attachment\Model\Entity\Attachment $attachment the attachment entity to add the tag to
  * @return string
  */
 public function tagsChooser(EntityInterface $entity, $attachment)
 {
     if (!TableRegistry::exists($entity->source())) {
         throw new Cake\Network\Exception\MissingTableException('Could not find Table ' . $entity->source());
     }
     $Table = TableRegistry::get($entity->source());
     return $this->Form->select('tags', $Table->getAttachmentsTags(), ['type' => 'select', 'class' => 'tag-chooser', 'style' => 'display: block; width: 100%', 'label' => false, 'multiple' => true, 'value' => $attachment->tags]);
 }
 public function afterSaveCommit(Event $event, EntityInterface $entity, \ArrayObject $options)
 {
     $rev = $this->_table->Revisions->newEntity();
     unset($entity->revisions);
     $rev->data = $entity->toArray();
     $rev->ref = $this->_table->alias();
     $rev->ref_id = $entity->id;
     $this->_table->Revisions->save($rev);
 }
 /**
  * Generates IDs for an entity before it is saved to the database.
  *
  * @param Event $event Instance of save event
  * @param EntityInterface $entity Entity being saved
  */
 public function beforeSave(Event $event, EntityInterface $entity)
 {
     // Check if entity is being created in database
     // If so, update appropriate ID fields if present
     if ($entity->isNew()) {
         $entity->set($this->config('base64.field'), $this->generateBase64Id());
         $entity->set($this->config('uuid.field'), $this->generateUuid());
     }
 }
예제 #14
0
 /**
  * Gets the repository for this entity
  *
  * @param EntityInterface $entity
  * @return Table
  */
 protected function _repository($entity)
 {
     $source = $entity->source();
     if ($source === null) {
         list(, $class) = namespaceSplit(get_class($entity));
         $source = Inflector::pluralize($class);
     }
     return TableRegistry::get($source);
 }
 /**
  * afterSave Callback
  *
  * @param Event $event CakePHP Event
  * @param EntityInterface $entity Entity that was saved
  * @return void
  */
 public function afterSave(Event $event, EntityInterface $entity)
 {
     $action = $entity->isNew() ? ModelHistory::ACTION_CREATE : ModelHistory::ACTION_UPDATE;
     $dirtyFields = null;
     if ($action === ModelHistory::ACTION_UPDATE && isset($this->_dirtyFields[$entity->id])) {
         $dirtyFields = $this->_dirtyFields[$entity->id];
         unset($this->_dirtyFields[$entity->id]);
     }
     $this->ModelHistory->add($entity, $action, $this->_getUserId(), ['dirtyFields' => $dirtyFields]);
 }
예제 #16
0
 public function toggle(EntityInterface $entity)
 {
     $limit = $this->config('implementedServices.' . $entity->source())->config('limit');
     if ($limit !== 1) {
         throw new Exception(sprintf('Toggle disabled, type "%s" limit is "%s"', $entity->source(), $limit));
     }
     // if current user in $entity->reviewed_by
     // if so goto unreview
     // else goto review
 }
예제 #17
0
 public function beforeSave(Event $event, EntityInterface $entity, ArrayObject $options)
 {
     if (empty($entity->display)) {
         $entity->display = Inflector::humanize($entity->name);
     }
     if ($entity->dirty('is_default') && $entity->is_default) {
         $this->updateAll(['is_default' => false], ['is_default' => true]);
     } elseif ($entity->dirty('is_default') && !$entity->is_default) {
         $entity->is_default = $entity->getOriginal('is_default');
     }
 }
 /**
  * Gets the image version data used to generate the versions.
  *
  * @param \Cake\Datasource\EntityInterface $entity An ImageStorage database record.
  * @param array $options Options for the version.
  * @return array Version data information as array.
  */
 protected function _getImageVersionData(EntityInterface $entity, array $options = [])
 {
     $versionData = (array) Configure::read('FileStorage.imageSizes.' . $entity->get('model'));
     if (isset($options['originalVersion'])) {
         $versionData['original'] = $options['originalVersion'];
     } else {
         Configure::write('FileStorage.imageSizes.' . $entity->get('model') . '.original', []);
         $versionData['original'] = [];
     }
     $versionData['original'] = isset($options['originalVersion']) ? $options['originalVersion'] : 'original';
     return $versionData;
 }
예제 #19
0
 /**
  * Event listener to encrypt data.
  *
  * @param \Cake\Event\Event $event Event.
  * @param \Cake\Datasource\EntityInterface $entity Entity.
  * @return void
  */
 public function beforeSave(Event $event, EntityInterface $entity)
 {
     $driver = $this->_table->connection()->driver();
     foreach ($this->config('fields') as $field => $type) {
         if (!$entity->has($field)) {
             continue;
         }
         $raw = $entity->get($field);
         $plain = Type::build($type)->toDatabase($raw, $driver);
         $entity->set($field, $this->encrypt($plain));
     }
 }
예제 #20
0
 /**
  * DRY for update active and token based on validateEmail flag
  *
  * @param EntityInterface $user User to be updated.
  * @param type $validateEmail email user to validate.
  * @param type $tokenExpiration token to be updated.
  * @return EntityInterface
  */
 protected function _updateActive(EntityInterface $user, $validateEmail, $tokenExpiration)
 {
     $emailValidated = $user['validated'];
     if (!$emailValidated && $validateEmail) {
         $user['active'] = false;
         $user->updateToken($tokenExpiration);
     } else {
         $user['active'] = true;
         $user['activation_date'] = new Time();
     }
     return $user;
 }
 /**
  * Save the file to the storage backend after the record was created.
  *
  * @param \Cake\Event\Event $event
  * @param \Cake\Datasource\EntityInterface $entity
  * @return void
  */
 public function afterSave(Event $event, EntityInterface $entity)
 {
     if ($this->_checkEvent($event) && $entity->isNew()) {
         $fileField = $this->config('fileField');
         $entity['hash'] = $this->getFileHash($entity, $fileField);
         $entity['path'] = $this->pathBuilder()->path($entity);
         if (!$this->_storeFile($event)) {
             return;
         }
         $event->stopPropagation();
     }
 }
예제 #22
0
 /**
  * Performs the uniqueness check
  *
  * @param \Cake\Datasource\EntityInterface $entity The entity from where to extract the fields
  * @param array $options Options passed to the check,
  * where the `repository` key is required.
  * @return bool
  */
 public function __invoke(EntityInterface $entity, array $options)
 {
     if (!$entity->extract($this->_fields, true)) {
         return true;
     }
     $conditions = $entity->extract($this->_fields);
     if ($entity->isNew() === false) {
         $keys = (array) $options['repository']->primaryKey();
         $keys = $entity->extract($keys);
         if (array_filter($keys, 'strlen')) {
             $conditions['NOT'] = $keys;
         }
     }
     return !$options['repository']->exists($conditions);
 }
예제 #23
0
 /**
  * Validates a single entity by getting the correct validator object from
  * the table and traverses associations passed in $options to validate them
  * as well.
  *
  * @param \Cake\Datasource\EntityInterface $entity The entity to be validated
  * @param array|\ArrayObject $options options for validation, including an optional key of
  *   associations to also be validated. This argument should use the same format as the $options
  *   argument to \Cake\ORM\Table::save().
  * @return bool true if all validations passed, false otherwise
  */
 public function one(EntityInterface $entity, $options = [])
 {
     $valid = true;
     $types = [Association::ONE_TO_ONE, Association::MANY_TO_ONE];
     $propertyMap = $this->_buildPropertyMap($options);
     $options = new ArrayObject($options);
     foreach ($propertyMap as $key => $assoc) {
         $value = $entity->get($key);
         $association = $assoc['association'];
         if (!$value) {
             continue;
         }
         $isOne = in_array($association->type(), $types);
         if ($isOne && !$value instanceof EntityInterface) {
             $valid = false;
             continue;
         }
         $validator = new self($association->target());
         if ($isOne) {
             $valid = $validator->one($value, $assoc['options']) && $valid;
         } else {
             $valid = $validator->many($value, $assoc['options']) && $valid;
         }
     }
     if (!isset($options['validate'])) {
         $options['validate'] = true;
     }
     if (!$entity instanceof ValidatableInterface) {
         return $valid;
     }
     return $this->_processValidation($entity, $options) && $valid;
 }
 /**
  * Save the file to the storage backend after the record was created.
  *
  * @param \Cake\Event\Event $event
  * @param \Cake\Datasource\EntityInterface $entity
  * @return void
  */
 public function afterSave(Event $event, EntityInterface $entity)
 {
     if ($this->_checkEvent($event) && $entity->isNew()) {
         $fileField = $this->config('fileField');
         $entity['hash'] = $this->getFileHash($entity, $fileField);
         $entity['path'] = $this->pathBuilder()->fullPath($entity);
         if (!$this->_storeFile($event)) {
             return;
         }
         if ($this->_config['imageProcessing'] === true) {
             $this->autoProcessImageVersions($entity, 'create');
         }
         $event->result = true;
         $event->stopPropagation();
     }
 }
 /**
  * Save also related model data
  *
  * @param \Cake\Event\Event
  * @param \Cake\ORM\Entity;
  * @return void
  */
 public function beforeSave(Event $event, EntityInterface $entity, \ArrayObject $options)
 {
     foreach ($this->config('fields') as $field => $mapped) {
         list($mappedTable, $mappedField) = explode('.', $mapped);
         if (!isset($this->_table->{$mappedTable}) || $this->_table->{$mappedTable}->isOwningSide($this->_table)) {
             throw new Exception(sprintf('Incorrect definition of related data to persist for %s', $mapped));
         }
         $foreign = $entity->get($this->_table->{$mappedTable}->foreignKey());
         if (!is_null($foreign)) {
             // get related entity
             $related = $this->_table->{$mappedTable}->get($foreign);
             // set field value
             $entity->set($field, $related->get($mappedField));
         }
     }
 }
 /**
  * Modify entity
  *
  * @param \Cake\Datasource\EntityInterface entity
  * @param \Cake\ORM\Association table
  * @param string path prefix
  * @return void
  */
 protected function _modifyEntity(EntityInterface $entity, Association $table = null, $pathPrefix = '')
 {
     if (is_null($table)) {
         $table = $this->_table;
     }
     // unset primary key
     unset($entity->{$table->primaryKey()});
     // unset foreign key
     if ($table instanceof Association) {
         unset($entity->{$table->foreignKey()});
     }
     // unset configured
     foreach ($this->config('remove') as $field) {
         $field = $this->_fieldByPath($field, $pathPrefix);
         if ($field) {
             unset($entity->{$field});
         }
     }
     // set / prepend / append
     foreach (['set', 'prepend', 'append'] as $action) {
         foreach ($this->config($action) as $field => $value) {
             $field = $this->_fieldByPath($field, $pathPrefix);
             if ($field) {
                 if ($action == 'prepend') {
                     $value .= $entity->{$field};
                 }
                 if ($action == 'append') {
                     $value = $entity->{$field} . $value;
                 }
                 $entity->{$field} = $value;
             }
         }
     }
     // set as new
     $entity->isNew(true);
     // modify related entities
     foreach ($this->config('contain') as $contain) {
         if (preg_match('/^' . preg_quote($pathPrefix, '/') . '([^.]+)/', $contain, $matches)) {
             foreach ($entity->{Inflector::tableize($matches[1])} as $related) {
                 if ($related->isNew()) {
                     continue;
                 }
                 $this->_modifyEntity($related, $table->{$matches[1]}, $pathPrefix . $matches[1] . '.');
             }
         }
     }
 }
예제 #27
0
 /**
  * Extracts nested validation errors
  *
  * @param EntityInterface $entity Entity to extract
  *
  * @return array
  */
 protected function _getErrors(EntityInterface $entity)
 {
     $errors = $entity->errors();
     foreach ($entity->visibleProperties() as $property) {
         $v = $entity[$property];
         if ($v instanceof EntityInterface) {
             $errors[$property] = $this->_getErrors($v);
         } elseif (is_array($v)) {
             foreach ($v as $key => $varValue) {
                 if ($varValue instanceof EntityInterface) {
                     $errors[$property][$key] = $this->_getErrors($varValue);
                 }
             }
         }
     }
     return Hash::filter($errors);
 }
예제 #28
0
 /**
  * Performs the existence check
  *
  * @param \Cake\Datasource\EntityInterface $entity The entity from where to extract the fields
  * @param array $options Options passed to the check,
  * where the `repository` key is required.
  * @return bool
  */
 public function __invoke(EntityInterface $entity, array $options)
 {
     if (is_string($this->_repository)) {
         $this->_repository = $options['repository']->association($this->_repository);
     }
     if (!empty($options['_sourceTable'])) {
         $source = $this->_repository instanceof Association ? $this->_repository->target() : $this->_repository;
         if ($source === $options['_sourceTable']) {
             return true;
         }
     }
     if (!$entity->extract($this->_fields, true)) {
         return true;
     }
     $conditions = array_combine((array) $this->_repository->primaryKey(), $entity->extract($this->_fields));
     return $this->_repository->exists($conditions);
 }
 /**
  * Triggers the callback "afterDetach", it also deletes all associated records
  * in the "field_values" table.
  *
  * @param \Cake\Event\Event $event The event that was triggered
  * @param \Field\Model\Entity\FieldInstance $instance The Field Instance that was deleted
  * @param \ArrayObject $options the options passed to the delete method
  * @return void
  */
 public function afterDelete(Event $event, FieldInstance $instance, ArrayObject $options = null)
 {
     if (!empty($this->_deleted)) {
         TableRegistry::get('Eav.EavAttributes')->delete($this->_deleted->get('eav_attribute'));
         $instance->afterDetach();
         $this->_deleted = null;
     }
 }
예제 #30
0
 /**
  * Cascade a delete to remove dependent records.
  *
  * This method does nothing if the association is not dependent.
  *
  * @param \Cake\Datasource\EntityInterface $entity The entity that started the cascaded delete.
  * @param array $options The options for the original delete.
  * @return bool Success.
  */
 public function cascadeDelete(EntityInterface $entity, array $options = [])
 {
     if (!$this->dependent()) {
         return true;
     }
     $table = $this->target();
     $foreignKey = (array) $this->foreignKey();
     $bindingKey = (array) $this->bindingKey();
     $conditions = array_combine($foreignKey, $entity->extract($bindingKey));
     if ($this->_cascadeCallbacks) {
         foreach ($this->find()->where($conditions)->toList() as $related) {
             $table->delete($related, $options);
         }
         return true;
     }
     $conditions = array_merge($conditions, $this->conditions());
     return $table->deleteAll($conditions);
 }