Updates the notes fields of the subscription without generating a SubscriptionChange.

@param array $notes Array of notes, allowed keys: (customer_notes, terms_and_conditions, vat_reverse_charge_notes)
@throws Recurly_Error
510650
public function updateNotes($notes) {
    $this->setValues($notes)->_save(Recurly_Client::PUT, $this->uri() . '/notes');
  }
1054153
public function notes($notes = null)
    {
        if (is_null($notes)) {
            return $this->notes;
        }

        $this->notes = $notes;

        return $this;
    }
483079
function addNote($note) {
        if (!count($this->layers)) {
            $layer = new Layer();
            $this->addLayer($layer);
        } else {
            $layer = $this->layers[0];
        }

        $layer->addNote($note);

    }
1080799
public function setPunctuationReplacements($replacements)
        {
            if(!is_array($replacements)) {
                throw new \Thin\Exception(__METHOD__ . ': method expects a keyed array as argument.', 500);
            }
            foreach($replacements as $key => $value) {
                $this->punctuation[$key] = $value;
            }
            return $this;
        }
422388
public function setNote($note)
    {
        global $CFG;
        $PDOX = $this->launch->pdox;

        $stmt = $PDOX->queryDie(
            "UPDATE {$CFG->dbprefix}lti_result SET note = :note, updated_at = NOW()
                WHERE result_id = :RID",
            array(
                ':note' => $note,
                ':RID' => $this->id)
        );
    }
546005
public function getNotes()
    {
        $notes = [];
        if ($this->entity->getNotes()) {
            foreach ($this->entity->getNotes() as $note) {
                $notes[] = $note;
            }
        }

        return $notes;
    }
307567
public function setNotes($value)
    {
        $this->values['notes'] = [];

        if ($value instanceof Note) {
            $value = [$value];
        }

        foreach ($value as $note) {
            if ($note instanceof Note) {
                $note = $note->getValues();
            }

            $this->values['notes'][] = $note;
        }

        return $this;
    }
1131486
public function setFields (array $fields)
    {
        $this->_fields = array();
        $this->_records = array();
        $prevLevel = null;
        foreach ($fields as $field) {
            $level = $field->getLevel();
            if ($level === 0) {
                $this->append($field);
            } else {
                if ($level === 1 && $prevLevel !== 1) {
                    $localRecord = new LocalRecord(array($field));
                    $this->addLocalRecord($localRecord);
                } else {
                    $records = $this->getLocalRecords();
                    // Handle malformed Pica record w/ missing local record field
                    if (empty($records)) {
                        $localRecord = new LocalRecord();
                        $this->addLocalRecord($localRecord);
                    } else {
                        $localRecord = end($records);
                    }
                    if ($level === 1) {
                        $localRecord->append($field);
                    } else {
                        $copyRecord = $localRecord->getCopyRecordByItemNumber($field->getOccurrence());
                        if ($copyRecord) {
                            $copyRecord->append($field);
                        } else {
                            $localRecord->addCopyRecord(new CopyRecord(array($field)));
                        }
                    }
                }
            }
            $prevLevel = $level;
        }
    }
54004
public function modify(array $properties)
  {
    $properties["clid"] = $this->getId();

    $this->execute("clientedit", $properties);
    $this->resetNodeInfo();
  }
434293
protected function updateFromDirectives(array $directives)
    {
        $this->directives = $directives;
        $this->values = array();

        foreach ($directives as $key => $value) {
            $this->values[] = $value === true ? $key : "{$key}={$value}";
        }
    }
105882
def update_note(note_id: NoteId, body: Body=None, done: Done=None) -> Note:
    """"""
    if note_id != 1:
        raise NotFoundError('Note does not exist')
    new_note = note.copy()
    if body is not None:
        new_note['body'] = body
    if done is not None:
        new_note['done'] = done
    return new_note
401375
public function setMergeFields(array $mergeFields)
    {
        // since fev2017, MailChimp API doesn't handle null value en throw 400
        // errors when you try to add subscriber with a mergefields value to null
        foreach ($mergeFields as $key => $value) {
            if ($value === null) {
                unset($mergeFields[$key]);
            }
        }
        $this->mergeFields = $mergeFields;

        return $this->mergeFields;
    }
822784
public function setSections(array $sections)
    {
        foreach ($sections as $key => $config) {
            // Watch out for old config data that's not updated yet
            if (!isset($config['sectionUid'])) {
                continue;
            }

            // Ignore sections that don't allow guest submissions
            if ($config['allowGuestSubmissions']) {
                $this->_sections[$config['sectionUid']] = new SectionSettings($config);
            } else {
                unset($this->_sections[$config['sectionUid']]);
            }
        }
    }
539571
public function setRecurrences($recurrences)
    {
        if (!is_numeric($recurrences) && !is_null($recurrences) || $recurrences < 0) {
            throw new InvalidArgumentException('Invalid number of recurrences.');
        }

        if ($recurrences === null) {
            return $this->removeFilter(static::RECURRENCES_FILTER);
        }

        $this->recurrences = (int) $recurrences;

        if (!$this->hasFilter(static::RECURRENCES_FILTER)) {
            return $this->addFilter(static::RECURRENCES_FILTER);
        }

        $this->handleChangedParameters();

        return $this;
    }
182425
public function addSnippets(array $snippets = null) {

        // register default snippets
        $this->add(new DefaultSnippets());

        if(!is_null($snippets)) {
            foreach ($snippets as $snippet=>$definition) {
                if ($definition instanceof Snippets) {
                    $this->add($definition);
                } else {
                    $this->add($snippet, $definition);
                }
            }
        }
    }
69298
public function setRevisions(array $revisions)
    {
        $this->revisions = new ArrayCollection();

        /** @var \Rcm\Entity\Revision $revision */
        foreach ($revisions as $revision) {
            if (!$revision instanceof Revision) {
                throw new InvalidArgumentException(
                    "Invalid Revision passed in.  Unable to set array"
                );
            }

            $this->revisions->set($revision->getRevisionId(), $revision);
        }
    }
1084189
public function triggerSubscriptionExpired(SubscriptionInterface $subscription, $note)
    {
        $this->trigger(self::ON_SUBSCRIPTION_EXPIRED, $subscription, $note);
    }