Updates a delivery note

        :param delivery_note_id: the delivery note id
        :param delivery_note_dict: dict
        :return: dict
764084
def update_delivery_note(self, delivery_note_id, delivery_note_dict):
        
        return self._create_put_request(
            resource=DELIVERY_NOTES,
            billomat_id=delivery_note_id,
            send_data=delivery_note_dict
        )
635412
def update(self, id, **dict):
        ''''''
        if not self._item_path:
            raise AttributeError('update is not available for %s' % self._item_name)
        target = (self._update_path or self._item_path) % id
        payload = json.dumps({self._item_type:dict})
        self._redmine.put(target, payload)
        return None
1185126
def delivery_note_pdf(self, delivery_note_id):
        
        return self._create_get_request(resource=DELIVERY_NOTES, billomat_id=delivery_note_id, command=PDF)
281984
def get_tags_of_delivery_note_per_page(self, delivery_note_id, per_page=1000, page=1):
        
        return self._get_resource_per_page(
            resource=DELIVERY_NOTE_TAGS,
            per_page=per_page,
            page=page,
            params={'delivery_note_id': delivery_note_id},
        )
1229926
def purge_note(note_id, **kwargs):
    
    note_i = _get_note(note_id)

    db.DBSession.delete(note_i)

    db.DBSession.flush()
503829
def post_copy_notes(self, post_id, other_post_id):
        
        return self._get('posts/{0}/copy_notes.json'.format(post_id),
                         {'other_post_id': other_post_id}, 'PUT', auth=True)
1121663
def update_todo_item(self, item_id, content, party_id=None, notify=False):
        
        path = '/todos/update_item/%u' % item_id
        req = ET.Element('request')
        item = ET.Element('request')
        ET.SubElement(item, 'content').text = str(content)
        if party_id is not None:
            ET.SubElement(req, 'responsible-party').text = str(party_id)
            ET.SubElement(req, 'notify').text = str(bool(notify)).lower()
        return self._request(path, req)
678083
def set_notebook(note_store, my_notebook, notebook_id):
        
        if notebook_id == 0:
            new_notebook = Types.Notebook()
            new_notebook.name = my_notebook
            new_notebook.defaultNotebook = False
            notebook_id = note_store.createNotebook(new_notebook).guid
        return notebook_id
185633
def get_comments_of_delivery_note_per_page(self, delivery_note_id, per_page=1000, page=1):
        
        return self._get_resource_per_page(
            resource=DELIVERY_NOTE_COMMENTS,
            per_page=per_page,
            page=page,
            params={'delivery_note_id': delivery_note_id},
        )
1100666
def update_notes(self, **kwargs):
        
        for key, val in iteritems(kwargs):
            setattr(self, key, val)
        url = urljoin(self._url, '/notes')
        self.put(url)
599259
def add_note(self, body):
        
        from highton.models.note import Note
        created_id = self._post_request(
            endpoint=self.ENDPOINT + '/' + str(self.id) + '/' + Note.ENDPOINT,
            data=self.element_to_string(
                Note(body=body).encode()
            )
        ).headers.get('Location').replace('.xml', '').split('/')[-1]
        return Note.get(created_id)
1326194
def _update_id(record, new_id):
    
    old_id = record.id
    record.id = new_id

    # At least for FASTA, record ID starts the description
    record.description = re.sub('^' + re.escape(old_id), new_id, record.description)
    return record
851617
def update_note(self, note_id, revision, content):
        '''  '''
        return notes_endpoint.update_note(self, note_id, revision, content)
666180
def get_all_delivery_notes(self, params=None):
        
        if not params:
            params = {}
        return self._iterate_through_pages(
            self.get_delivery_notes_per_page,
            resource=DELIVERY_NOTES,
            **{'params': params}
        )
1181039
def note_versions(self, updater_id=None, post_id=None, note_id=None):
        
        params = {
            'search[updater_id]': updater_id,
            'search[post_id]': post_id,
            'search[note_id]': note_id
            }
        return self._get('note_versions.json', params)
597046
def retrieve(self, request, project, pk=None):
        
        try:
            serializer = JobNoteSerializer(JobNote.objects.get(id=pk))
            return Response(serializer.data)
        except JobNote.DoesNotExist:
            return Response("No note with id: {0}".format(pk), status=HTTP_404_NOT_FOUND)
719031
def note_revert(self, note_id, version_id):
        
        return self._get('notes/{0}/revert.json'.format(note_id),
                         {'version_id': version_id}, method='PUT', auth=True)