Edit a batch of items

@param array $parameters
@param bool  $createIfNotExists

@return array|mixed
428388
public function editBatch(array $parameters, $createIfNotExists = false)
    {
        $method    = $createIfNotExists ? 'PUT' : 'PATCH';
        $supported = $this->isSupported('editBatch');

        return (true === $supported) ? $this->makeRequest($this->endpoint.'/batch/edit', $parameters, $method) : $supported;
    }
706555
public function create($ifNotExists = false, $charset = 'utf8')
    {
        if ($ifNotExists && $this->exists()) {
            return $this;
        }

        $query = PostgresqlGrammar::createDatabase($this->name, $charset);

        $this->db->setQuery($query)->execute();

        return $this;
    }
1370147
public static function create($parameters)
    {
        if (is_string($parameters)) {
            return self::fromString($parameters);
        }

        if (is_array($parameters)) {
            return self::fromArray($parameters);
        }

        throw new InvalidArgumentException('Invalid parameters type');
    }
100509
public function create(array $parameters) {
        $toolbarItem = new FormToolbarItem($parameters['action']);
        unset($parameters['action']);
        foreach($parameters as $key => $value) {
            $toolbarItem->$key = $value;
        }
        return $toolbarItem;
    }
301131
public function addConditions(...$parameters)
    {
        if (count($parameters) > 0) {
            if (is_array($parameters[0])) {
                foreach ($parameters as $parameter) {
                    $this->addConditions(...$parameter);
                }
            } else {
                if (!isset($parameters[2])) {
                    $parameters[2] = Comparison::determineComparison($parameters[1]);
                }
                
                $parameters[1] = is_array($parameters[1]) ? new Expr\Parameters($parameters[1]) : $parameters[1];
                $this->where(...$parameters);
            }
        }
        
        return $this;
    }
726287
public function create(array $elements, array $parameters = [])
    {
        $this->validateParameters($parameters);
        $factory = new ListCollectionFactory();
        $list = $factory->create(
            $elements,
            (isset($parameters['headers'])) ? $parameters['headers'] : [],
            (isset($parameters['uuid'])) ? $parameters['uuid'] : null,
            (isset($parameters['element-uuid'])) ? $parameters['element-uuid'] : null
        );

        return $this->repository->create(
            $list,
            (isset($parameters['ttl'])) ? $parameters['ttl'] : null,
            (isset($parameters['chunk-size'])) ? $parameters['chunk-size'] : null
        );
    }
391057
public function create($ifNotExists = false, $charset = 'utf8', $collate = 'utf8_unicode_ci')
    {
        $query = MysqlGrammar::createDatabase($this->name, $ifNotExists, $charset, $collate);

        $this->db->setQuery($query)->execute();

        return $this;
    }
17428
protected function appendPsForUniqueClauseTo(&$sb, array &$params)
    {
        if (1 !== substr_count($this->column, '?')) {
            throw new InvalidClauseException(sprintf('Could not build SQL for expression "%s" because Criteria::RAW works only with a clause containing a single question mark placeholder', $this->column));
        }
        $params[] = ['table' => null, 'type' => $this->type, 'value' => $this->value];
        $sb .= str_replace('?', ':p' . count($params), $this->column);
    }
731861
public function add(array $parameters)
    {
        foreach ($parameters as $identifier => $value) {
            $this->set($identifier, $value, false);
        }

        return $this;
    }
1320992
public function create(array $params = [])
    {
        return $this->executeRequest(
            RequestMethodEnum::POST,
            ResourceMethodEnum::CREATE,
            $params,
            null
        );
    }
1365162
public function create(RetentionPolicy $retentionPolicy = null, $createIfNotExists = false)
    {
        if ($createIfNotExists) {
            trigger_error('The $createIfNotExists parameter to Database::create is deprecated', E_USER_DEPRECATED);
        }
        try {
            $query = sprintf('CREATE DATABASE "%s"', $this->name);

            $this->query($query);

            if ($retentionPolicy) {
                $this->createRetentionPolicy($retentionPolicy);
            }
        } catch (Exception $e) {
            throw new DatabaseException(
                sprintf('Failed to created database %s', $this->name),
                $e->getCode(),
                $e
            );
        }
    }
525785
public function createCustomer($parameters = [])
    {
        $response = $this->client->post('customers', [
            'json' => $parameters,
        ]);
        return json_decode($response->getBody())->customer;
    }
397673
protected function _createIndexIfNotExists() {
        $service        = $this->getService();
        $indexExists    = $service->doesIndexExist();

        if ($indexExists) {
            return self::MSG_INDEX_EXISTS;
        }

        return $service->createIndex()
            ? self::MSG_INDEX_CREATED
            : self::MSG_INDEX_CREATION_FAILURE;
    }
204806
public function create($params = array())
    {
        $path = "/subscriptions";
        if(isset($params['params'])) { 
            $params['body'] = json_encode(array($this->envelope_key => (object)$params['params']));
        
            unset($params['params']);
        }

        
        try {
            $response = $this->api_client->post($path, $params);
        } catch(InvalidStateException $e) {
            if ($e->isIdempotentCreationConflict()) {
                return $this->get($e->getConflictingResourceId());
            }

            throw $e;
        }
        

        return $this->getResourceForResponse($response);
    }
714939
public function editLocations($locations)
     {
         $new_ids = (array) AnConfig::unbox($locations->id);

         foreach ($this->locations as $location) {
             if (!in_array($location->id, $new_ids)) {
                 if ($edge = $this->locations->find($location)) {
                     $edge->delete();
                 }
             }
         }

         $newItems = AnHelperArray::getIterator($locations);

         foreach ($newItems as $item) {
             if (! $this->locations->find($item)) {
                 $this->locations->insert( $item );
             }
         }

         return $this;
     }
250669
public function create(array $parameters)
    {
        $supported = $this->isSupported('create');

        return (true === $supported) ? $this->makeRequest($this->endpoint.'/new', $parameters, 'POST') : $supported;
    }
194605
public function removeParameters(array $parameters = null)
  {
    $this->parameters = array();

    if ($parameters) {
      $this->addParameters($parameters);
    }

    return $this;
  }