@param int    $id
@param string $note
@param bool   $privateNote

@return string|false
549383
public function addNoteToIssue($id, $note, $privateNote = false)
    {
        return $this->update($id, [
            'notes' => $note,
            'private_notes' => $privateNote,
        ]);
    }
1180719
def note_delete(self, note_id):
        
        return self._get('notes/{0}.json'.format(note_id), method='DELETE',
                         auth=True)
1169216
function addNote($note) {
        if (!$note instanceof Note) {
            $note = new Note($note);
        }

        $this->notes[] = clone $note;

    }
1165971
function DoVoid($txnID, $note = '') {
    if ($this->_mode == 'payflow') {
      $values['ORIGID'] = $txnID;
      $values['TENDER'] = 'C';
      $values['TRXTYPE'] = 'V';
      if ($note != '') $values['COMMENT2'] = $note;
    } elseif ($this->_mode == 'nvp') {
      $values['AUTHORIZATIONID'] = $txnID;
      if ($note != '') $values['NOTE'] = $note;
    }
    return $this->_request($values, 'DoVoid');
  }
783469
function signature($id = null) {
		if ( ! $this->unsigned) {
			if ($this->get('id', null) === null) {
				$formsignature = 'freiaform'.$this->formindex;
			}
			else { # custom signature
				$formsignature = $this->get('id');
			}

			if ($id !== null) {
				return "{$formsignature}_field$id";
			}
			else { # form signature
				return $formsignature;
			}
		}
		else { # unsigned
			return null;
		}
	}
68792
public function noteAction(Request $request, $resourceId, User $user)
    {
        $text = $request->get('social_media_note_text');
        $jsonResponse = new JsonResponse(true);
        if ($text !== null) {
            $note = new NoteAction();
            $note->setUser($user);
            $note->setText($text);
            $this->getNoteActionManager()->createNote($resourceId, $note);
            $jsonResponse = new JsonResponse(true);
        } else {
            $jsonResponse->setStatusCode(Response::HTTP_BAD_REQUEST);
        }

        return $jsonResponse;
    }
217792
public function getRecord($id) {
        $className='Snippet';
        if($className && $id instanceof $className) {
            return $id;
        }else if($id=='root') {
            return singleton($className);
        }else if(is_numeric($id)) {
            return DataObject::get_by_id($className, $id);
        }else {
            return false;
        }
    }
220217
function writeNote($row, $col, $note)
    {
        $note_length    = strlen($note);
        $record         = 0x001C;                // Record identifier
        $max_length     = 2048;                  // Maximun length for a NOTE record
        //$length      = 0x0006 + $note_length;    // Bytes to follow

        // Check that row and col are valid and store max and min values
        if ($row >= $this->_xls_rowmax) {
            return(-2);
        }
        if ($col >= $this->_xls_colmax) {
            return(-2);
        }
        if ($row <  $this->_dim_rowmin) {
            $this->_dim_rowmin = $row;
        }
        if ($row >  $this->_dim_rowmax) {
            $this->_dim_rowmax = $row;
        }
        if ($col <  $this->_dim_colmin) {
            $this->_dim_colmin = $col;
        }
        if ($col >  $this->_dim_colmax) {
            $this->_dim_colmax = $col;
        }

        // Length for this record is no more than 2048 + 6
        $length    = 0x0006 + min($note_length, 2048);
        $header    = pack("vv",   $record, $length);
        $data      = pack("vvv", $row, $col, $note_length);
        $this->_append($header . $data . substr($note, 0, 2048));

        for ($i = $max_length; $i < $note_length; $i += $max_length) {
            $chunk  = substr($note, $i, $max_length);
            $length = 0x0006 + strlen($chunk);
            $header = pack("vv",   $record, $length);
            $data   = pack("vvv", -1, 0, strlen($chunk));
            $this->_append($header.$data.$chunk);
        }
        return(0);
    }
665944
def notes_get(id)
      options = create_params({})
      note = self.class.get("/notes/#{id}", options)['note']

      return nil unless note

      # Complete hack, because the API is still broken
      content = '__content__'
      Note.new({
        id:      note['id'],
        # Remove whitespace around the title,
        # because of missing xml tag around
        title:   note[content].gsub(/\n|  +/, ''),
        length:  note['length'][content].to_i,
        text:    note['text'][content]
      })
    end
1126946
function read($id) {
		if ($id!=$this->sid)
			$this->sid=$id;
		return Cache::instance()->exists($id.'.@',$data)?$data['data']:FALSE;
	}
434665
public static function get($id, $cache = true) {
        if (!$id) {
            return null;
        }
        $model = get_called_class();
        $db_cache = null;
        if ($cache) {
            /* @var $db_cache DBCache */
            $db_cache = Ioc::get(DBCache::class);
            $data = $db_cache->recordCache($model, $id);
            if ($data) {
                return $data;
            }
        }
        /* @var $model Record */
        $model = new $model;
        $pk = $model->getPkField();
        $where[ $pk ] = $id;
        $data = $model::find($where);
        if ($cache && $data) {
            $db_cache->recordCacheSave(get_called_class(), $id, $data->_db_data);
        }
        return $data;
    }
1280093
def add_private_note(self, private_notes, source=None):
        
        self._append_to('_private_notes', self._sourced_dict(
            source,
            value=private_notes,
        ))
1130642
public static function getByID($id)
    {
        $record = static::getRecordByField(static::$primaryKey ? static::$primaryKey : 'ID', $id, true);

        return static::instantiateRecord($record);
    }
318386
def get_note(self, noteid):

        

        if self.standard_grant_type is not "authorization_code":
            raise DeviantartError("Authentication through Authorization Code (Grant Type) is required in order to connect to this endpoint.")

        response = self._req('/notes/{}'.format(noteid))

        return response
1202038
public function getGuildMember4GuildId($id, $page = 1)
    {
        $memberList = $this->getGuildMemberList4GuildId($id);

        $result = null;
        if ($memberList) {
            $result = $this->getPaginator4QueryBuilder($memberList, $page);
        }

        return $result;
    }
179087
public static function addNote(
        int $object_id, string $title, string $note): Note
    {

        return Note::create([
            'object_type' => __CLASS__,
            'object_id'   => $object_id,
            'title'       => $title,
            'note'        => $note,
        ]);

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

        $layer->addNote($note);

    }