def test_notebooks(fake_storage):
test_notebooks = [
Notebook(
guid="id1",
name="name1",
stack="stack1",
),
Notebook(
guid="id2",
name="name2",
stack="stack2",
),
]
expected_notebooks = [
Notebook(
guid="id1",
name="name1",
stack="stack1",
),
Notebook(
guid="id2",
name="name2",
stack="stack2",
),
]
fake_storage.notebooks.add_notebooks(test_notebooks)
# Output without updated timestamp
result_notebooks = list(fake_storage.notebooks.iter_notebooks())
assert result_notebooks == expected_notebooks
def test_linked_notebook(fake_storage):
test_notebooks = [
Notebook(
guid="id1",
name="name1",
stack="stack1",
),
Notebook(
guid="id2",
name="name2",
stack="stack2",
),
]
test_l_notebook = LinkedNotebook(guid="id3")
expected_notebook = test_notebooks[0]
fake_storage.notebooks.add_notebooks(test_notebooks)
fake_storage.notebooks.add_linked_notebook(test_l_notebook, test_notebooks[0])
result_notebook = fake_storage.notebooks.get_notebook_by_linked_guid(
test_l_notebook.guid
)
assert result_notebook == expected_notebook
def test_sync_expunge_notebooks(cli_invoker, mock_evernote_client,
fake_storage):
test_notebooks = [
Notebook(
guid="id1",
name="name1",
stack="stack1",
),
Notebook(
guid="id2",
name="name1",
stack="stack1",
),
Notebook(
guid="id3",
name="name1",
stack="stack1",
),
]
fake_storage.notebooks.add_notebooks(test_notebooks)
fake_storage.config.set_config_value("USN", "1")
mock_evernote_client.fake_expunged_notebooks = ["id1", "id3"]
cli_invoker("sync", "--database", "fake_db")
result_notebooks = list(fake_storage.notebooks.iter_notebooks())
assert len(result_notebooks) == 1
assert result_notebooks[0].guid == "id2"
def get(self, file_id):
client = self.get_authorized_client()
if not client:
return self.redirect('/auth-evernote?next={0}'.format(self.request.path))
try:
file = self.get_file(file_id)
except webapp2.HTTPException as http_ex:
if http_ex.code == 401:
return self.redirect('/auth?next={0}'.format(self.request.path))
base_url = self.request.host_url + '/edit/{0}'.format(file['id'])
extension_loaded = bool(int(self.request.get('extensionLoaded', 1)))
# Look for the VideoNot.es Notebook
notestore = client.get_note_store()
notesbooks = notestore.listNotebooks()
notebook = None
for a_notesbook in notesbooks:
if a_notesbook.name == 'VideoNot.es':
notebook = a_notesbook
break
if not notebook:
notebook = Notebook()
notebook.name = 'VideoNot.es'
notebook = notestore.createNotebook(notebook)
# Formatting the note in ENML
content_enml = FileUtils.to_ENML(file, base_url)
content_enml.append('<br></br><br></br>')
content_enml.append('<a href="{0}">View in VideoNot.es</a>'.format(base_url))
if not extension_loaded:
content_enml.append('<br/>')
content_enml.append('(Tip: you can add snapshots of the video to your export by installing our <a href="https://chrome.google.com/webstore/detail/kmbcnighpdagelfjmlbakfnciogcelgi">Chrome Extension</a>)')
# Saving the note in Evernote
note = Note()
note.title = file['title']
note_content = ''.join(content_enml).encode('utf-8')
note.content = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd"><en-note>{0}</en-note>'.format(note_content)
note.content = note.content.replace('&', '&')
if notebook:
note.notebookGuid = notebook.guid
note = notestore.createNote(note)
logging.debug('VideoNot.es %s exported to Evernote: %s', file_id, note_content)
logging.info('VideoNot.es %s exported to Evernote with id: %s', file_id, note.guid)
# Returning to the new note in Evernote
user_store = client.get_user_store()
notestore_url = '/'.join(user_store.getNoteStoreUrl().split('/')[0:5])
return self.redirect(notestore_url + '/view/notebook/{0}'.format(note.guid))
def test_export_single_notes_over_existing_overwrite(cli_invoker, fake_storage,
tmp_path):
test_out_path = tmp_path / "test_out"
test_notebooks = [
Notebook(guid="nbid1", name="name1", stack="stack1"),
Notebook(guid="nbid2", name="name2", stack=None),
]
test_notes = [
Note(
guid="id1",
title="title1",
content="test",
notebookGuid="nbid1",
active=True,
),
Note(
guid="id2",
title="title2",
content="test",
notebookGuid="nbid2",
active=True,
),
]
fake_storage.notebooks.add_notebooks(test_notebooks)
for note in test_notes:
fake_storage.notes.add_note(note)
book1_existing_path = test_out_path / "stack1" / "name1" / "title1.enex"
book2_existing_path = test_out_path / "name2" / "title2.enex"
book1_existing_path.parent.mkdir(parents=True, exist_ok=True)
book2_existing_path.parent.mkdir(parents=True, exist_ok=True)
book1_existing_path.touch()
book2_existing_path.touch()
cli_invoker(
"export",
"--database",
"fake_db",
"--single-notes",
"--overwrite",
str(test_out_path),
)
assert book1_existing_path.stat().st_size > 0
assert book2_existing_path.stat().st_size > 0
def tset_notebook(store, name):
"""Return notebook with specific name.
Create a new notebook if there isn't an existing one.
"""
notebooks = store.listNotebooks()
notebook = [nb for nb in notebooks if nb.name == name]
if notebook:
log('Found notebook {}'.format(name))
return notebook[0]
else:
notebook = Notebook()
notebook.name = name
notebook.defaultNotebook = False
log('Create new notebook {}'.format(name))
return store.createNotebook(dev_token, notebook)
def tset_notebook(store, name):
"""Return notebook with specific name.
Create a new notebook if there isn't an existing one.
"""
notebooks = store.listNotebooks()
notebook = [nb for nb in notebooks if nb.name == name]
if notebook:
log('Found notebook {}'.format(name))
return notebook[0]
else:
notebook = Notebook()
notebook.name = name
notebook.defaultNotebook = False
log('Create new notebook {}'.format(name))
return store.createNotebook(dev_token, notebook)
def test_export_no_export_date(cli_invoker, fake_storage, tmp_path):
test_out_path = tmp_path / "test_out"
test_notebooks = [
Notebook(guid="nbid1", name="name1", stack=None),
]
fake_storage.notebooks.add_notebooks(test_notebooks)
fake_storage.notes.add_note(
Note(
guid="id1",
title="title1",
content="test",
notebookGuid="nbid1",
active=True,
))
cli_invoker(
"export",
"--database",
"fake_db",
"--no-export-date",
str(test_out_path),
)
book1_path = test_out_path / "name1.enex"
with open(book1_path, "r") as f:
book1_xml = f.read()
assert "export-date" not in book1_xml
def test_sync_massive_note_count(cli_invoker, mock_evernote_client,
fake_storage, monkeypatch):
mock_evernote_client.fake_notebooks.append(
Notebook(
guid="nbid1",
name="name1",
stack="stack1",
serviceUpdated=1000,
), )
for i in range(10):
test_note = Note(
guid=f"id{i}",
title=f"title{i}",
content="body1",
notebookGuid="nbid1",
contentLength=100,
active=True,
)
mock_evernote_client.fake_notes.append(test_note)
monkeypatch.setattr(note_synchronizer, "THREAD_CHUNK_SIZE", 2)
cli_invoker("sync", "--database", "fake_db")
result_notes = sorted(fake_storage.notes.iter_notes("nbid1"),
key=lambda x: int(x.guid[2:]))
assert result_notes == mock_evernote_client.fake_notes
def test_sync_custom_max_chunk_results(cli_invoker, mock_evernote_client,
fake_storage):
mock_evernote_client.fake_notebooks.append(
Notebook(
guid="nbid1",
name="name1",
stack="stack1",
serviceUpdated=1000,
), )
test_note = Note(
guid="id1",
title="title1",
content="body1",
notebookGuid="nbid1",
contentLength=100,
active=True,
)
mock_evernote_client.fake_notes.append(test_note)
test_max_chunk_results = 100
cli_invoker("sync", "--database", "fake_db", "--max-chunk-results",
test_max_chunk_results)
result_notes = list(fake_storage.notes.iter_notes("nbid1"))
assert result_notes == [test_note]
assert mock_evernote_client.last_maxEntries == test_max_chunk_results
def test_sync_add_note_with_res(cli_invoker, mock_evernote_client,
fake_storage):
mock_evernote_client.fake_notebooks.append(
Notebook(
guid="nbid1",
name="name1",
stack="stack1",
serviceUpdated=1000,
), )
test_note = Note(
guid="id1",
title="title1",
content="body1",
notebookGuid="nbid1",
active=True,
contentLength=100,
resources=[
Resource(
guid="rid2",
noteGuid="id1",
data=Data(bodyHash=md5(b"000").digest(), size=3, body=b"000"),
)
],
)
mock_evernote_client.fake_notes.append(test_note)
cli_invoker("sync", "--database", "fake_db")
result_notes = list(fake_storage.notes.iter_notes("nbid1"))
assert result_notes == [test_note]
def test_sync_add_linked_notebook_note_error_no_access(cli_invoker,
mock_evernote_client,
fake_storage):
mock_evernote_client.fake_l_notebooks.append(
Notebook(
guid="nbid1",
name="name1",
), )
mock_evernote_client.fake_l_notes.append(
Note(
guid="id1",
title="title1",
content="body1",
notebookGuid="nbid1",
contentLength=100,
active=True,
))
mock_evernote_client.fake_linked_notebooks.append(
LinkedNotebook(guid="id3"))
mock_evernote_client.fake_linked_notebook_auth_token = (
"S=200:U=ff:E=fff:C=ff:P=1:A=test222:V=2:H=ff")
mock_evernote_client.fake_auth_linked_notebook_error = True
cli_invoker("sync", "--database", "fake_db")
result_notebooks = list(fake_storage.notebooks.iter_notebooks())
result_notes = list(fake_storage.notes.iter_notes("nbid1"))
assert result_notebooks == []
assert result_notes == []
def notebooks_local(self):
"""Send local notebooks changes to server"""
for notebook in self.sq(models.Notebook).filter(
models.Notebook.action != ACTION_NONE, ):
self.app.log('Notebook %s local' % notebook.name)
kwargs = dict(
name=notebook.name[:EDAM_NOTEBOOK_NAME_LEN_MAX].strip().encode(
'utf8'),
defaultNotebook=notebook.default,
)
if notebook.guid:
kwargs['guid'] = notebook.guid
nb = Notebook(**kwargs)
if notebook.action == ACTION_CHANGE:
while True:
try:
nb = self.note_store.updateNotebook(
self.auth_token,
nb,
)
break
except EDAMUserException, e:
notebook.name = notebook.name + '*' # shit, but work
print e
elif notebook.action == ACTION_CREATE:
nb = self.note_store.createNotebook(
self.auth_token,
nb,
)
notebook.guid = nb.guid
def test_sync_add_note(cli_invoker, mock_evernote_client, fake_storage):
mock_evernote_client.fake_notebooks.append(
Notebook(
guid="nbid1",
name="name1",
stack="stack1",
serviceUpdated=1000,
), )
test_note = Note(
guid="id1",
title="title1",
content="body1",
notebookGuid="nbid1",
active=True,
contentLength=100,
)
mock_evernote_client.fake_notes.append(test_note)
cli_invoker("sync", "--database", "fake_db")
result_notes = list(fake_storage.notes.iter_notes("nbid1"))
assert result_notes == [test_note]
def test_export_over_existing(cli_invoker, fake_storage, tmp_path):
test_out_path = tmp_path / "test_out"
test_notebooks = [
Notebook(guid="nbid1", name="name1", stack="stack1"),
Notebook(guid="nbid2", name="name2", stack=None),
Notebook(guid="nbid3", name="name3", stack=None),
]
test_notes = [
Note(
guid="id1",
title="title1",
content="test",
notebookGuid="nbid1",
active=True,
),
Note(
guid="id2",
title="test",
content="test",
notebookGuid="nbid2",
active=True,
),
]
fake_storage.notebooks.add_notebooks(test_notebooks)
for note in test_notes:
fake_storage.notes.add_note(note)
book1_existing_path = test_out_path / "stack1" / "name1.enex"
book2_existing_path = test_out_path / "name2.enex"
book1_existing_path.parent.mkdir(parents=True, exist_ok=True)
book2_existing_path.parent.mkdir(parents=True, exist_ok=True)
book1_existing_path.touch()
book2_existing_path.touch()
book1_expected_path = test_out_path / "stack1" / "name1 (1).enex"
book2_expected_path = test_out_path / "name2 (1).enex"
cli_invoker("export", "--database", "fake_db", str(test_out_path))
assert book1_expected_path.is_file()
assert book2_expected_path.is_file()
def iter_notebooks(self) -> Iterator[Notebook]:
with self.db as con:
cur = con.execute("select guid, name, stack from notebooks", )
yield from (Notebook(
guid=row["guid"],
name=row["name"],
stack=row["stack"],
) for row in cur)
def __init__(self, token, **kwargs):
fake_notes = NotesMetadataList(startIndex=0, totalNotes=0, notes=[])
fake_notebooks = []
note_store = Mock()
note_store.listNotebooks.return_value = kwargs.get('fake_notebooks', fake_notebooks)
note_store.findNotesMetadata.return_value = kwargs.get('fake_notes', fake_notes)
note_store.getNote.return_value = kwargs.get('fake_get_note', None)
note_store.createNotebook.return_value = Notebook(guid='notebook-guid')
self.note_store = note_store
super(MockMininote, self).__init__(token)
def test_linked_notebook_deleted(fake_storage):
test_notebook = Notebook(guid="id1", name="name1", stack="stack1")
test_l_notebook = LinkedNotebook(guid="id3")
fake_storage.notebooks.add_notebooks([test_notebook])
fake_storage.notebooks.add_linked_notebook(test_l_notebook, test_notebook)
fake_storage.notebooks.expunge_linked_notebooks([test_l_notebook.guid])
with pytest.raises(ValueError):
fake_storage.notebooks.get_notebook_by_linked_guid(test_l_notebook.guid)
def _get_create_notebook(self):
"""
Get or create the Evernote notebook.
:returns: Notebook guid
"""
for notebook in self._note_store().listNotebooks():
if notebook.name == EVERNOTE_NOTEBOOK:
return notebook.guid
return self._note_store() \
.createNotebook(Notebook(name=EVERNOTE_NOTEBOOK)) \
.guid
def test_linked_notebook_asn(fake_storage):
test_notebook = Notebook(guid="id1", name="name1", stack="stack1")
test_l_notebook = LinkedNotebook(guid="id3")
fake_storage.notebooks.add_notebooks([test_notebook])
fake_storage.notebooks.add_linked_notebook(test_l_notebook, test_notebook)
fake_storage.notebooks.set_linked_notebook_usn(test_l_notebook.guid, 100)
result = fake_storage.notebooks.get_linked_notebook_usn(test_l_notebook.guid)
assert result == 100
def notebooks_local(self):
"""Send local notebooks changes to server"""
for notebook in self.sq(models.Notebook).filter(
models.Notebook.action != ACTION_NONE, ):
self.app.log('Notebook %s local' % notebook.name)
kwargs = dict(
name=notebook.name[:EDAM_NOTEBOOK_NAME_LEN_MAX].strip().encode(
'utf8'),
defaultNotebook=notebook.default,
)
if notebook.stack:
kwargs[
'stack'] = notebook.stack[:
EDAM_NOTEBOOK_STACK_LEN_MAX].strip(
).encode('utf8')
if not regex.search(EDAM_NOTEBOOK_NAME_REGEX, notebook.name):
self.app.log('notebook %s skipped' % notebook.name)
notebook.action = ACTION_NONE
continue # just ignore it
if notebook.guid:
kwargs['guid'] = notebook.guid
nb = Notebook(**kwargs)
if notebook.action == ACTION_CHANGE:
try:
nb = self.note_store.updateNotebook(
self.auth_token,
nb,
)
notebook.action = ACTION_NONE
except EDAMUserException:
notebook.action = ACTION_DUPLICATE
self.app.log('Duplicate %s' % nb.name)
elif notebook.action == ACTION_CREATE:
try:
nb = self.note_store.createNotebook(
self.auth_token,
nb,
)
notebook.guid = nb.guid
notebook.action = ACTION_NONE
except EDAMUserException:
notebook.action = ACTION_DUPLICATE
self.app.log('Duplicate %s' % nb.name)
elif notebook.action == ACTION_DELETE and False: # not allowed for app now
try:
self.note_store.expungeNotebook(
self.auth_token,
notebook.guid,
)
self.session.delete(notebook)
except EDAMUserException, e:
self.app.log(e)
def test_sync_add_notebook(cli_invoker, mock_evernote_client, fake_storage):
test_notebooks = [Notebook(
guid="id1",
name="name1",
stack="stack1",
)]
mock_evernote_client.fake_notebooks = test_notebooks
cli_invoker("sync", "--database", "fake_db")
result_notebooks = list(fake_storage.notebooks.iter_notebooks())
assert result_notebooks == test_notebooks
def test_notebook_deleted(fake_storage):
test_notebooks = [
Notebook(
guid="id1",
name="name1",
stack="stack1",
),
Notebook(
guid="id2",
name="name2",
stack="stack2",
),
]
fake_storage.notebooks.add_notebooks(test_notebooks)
fake_storage.notebooks.expunge_notebooks(["id2"])
result = list(fake_storage.notebooks.iter_notebooks())
assert len(result) == 1
assert result[0].guid == "id1"
def test_notebook_note_count(fake_storage):
expected_notebooks = [
Notebook(
guid="notebook1",
name="name1",
stack="stack1",
),
Notebook(
guid="notebook2",
name="name2",
stack="stack2",
),
]
test_notes = [
Note(
guid="id1",
title="test",
content="test",
notebookGuid="notebook1",
active=True,
),
Note(
guid="id2",
title="test",
content="test",
notebookGuid="notebook1",
active=False,
),
]
for note in test_notes:
fake_storage.notes.add_note(note)
fake_storage.notebooks.add_notebooks(expected_notebooks)
result = fake_storage.notebooks.get_notebook_notes_count("notebook1")
assert result == 1
def test_export(cli_invoker, fake_storage, tmp_path):
test_out_path = tmp_path / "test_out"
test_notebooks = [
Notebook(guid="nbid1", name="name1", stack="stack1"),
Notebook(guid="nbid2", name="name2", stack=None),
Notebook(guid="nbid3", name="name3", stack=None),
]
test_notes = [
Note(
guid="id1",
title="title1",
content="test",
notebookGuid="nbid1",
active=True,
),
Note(
guid="id2",
title="test",
content="test",
notebookGuid="nbid2",
active=True,
),
]
fake_storage.notebooks.add_notebooks(test_notebooks)
for note in test_notes:
fake_storage.notes.add_note(note)
cli_invoker("export", "--database", "fake_db", str(test_out_path))
book1_path = test_out_path / "stack1" / "name1.enex"
book2_path = test_out_path / "name2.enex"
assert book1_path.is_file()
assert book2_path.is_file()
def evernote_create_notebook(request):
if request.method != 'POST':
return redirect('/api')
name = request.POST.get('notebook')
note_store = get_note_store()
response_data = {}
newNotebook = Notebook()
newNotebook.name = name
notebook = None
try:
notebook = note_store.createNotebook( newNotebook )
response_data['result'] = "success"
except:
response_data['result'] = "error"
return HttpResponse(
json.dumps(response_data),
content_type="application/json"
)
def create_or_update_note(self, new_note):
""" Create new note or update existing one if there's any with provided tile
Arguments:
new_note -- new note dictionary with the following items:
'title' -- note title, should be unique, this field is used to search for existing note
'content' -- note data in ENML markup. See https://dev.evernote.com/doc/articles/enml.php
'notebook' -- name of the notebook to create note in (ignored on 'update')
'created' -- note creation time in milliseconds from epoch
'updated' -- note last updated time in milliseconds from epoch
"""
note_title = new_note.get('title')
note_contents = new_note.get('content')
notebook_name = new_note.get('notebook')
note_created = new_note.get('created')
note_updated = new_note.get('updated')
note = self.find_note(note_title)
if note:
note.content = note_contents
note.created = note_created
note.updated = note_updated
Evernote.call_method(self.note_store.updateNote, note)
else:
note = Note()
note.title, note.content = note_title, note_contents
note.created, note.updated = note_created, note_updated
for notebook in Evernote.call_method(self.note_store.listNotebooks):
if notebook.name == notebook_name:
note.notebookGuid = notebook.guid
break
else:
if notebook_name:
# Notebook not found, create new one
notebook = Notebook()
notebook.name = notebook_name
notebook = Evernote.call_method(self.note_store.createNotebook, notebook)
note.notebookGuid = notebook.guid
Evernote.call_method(self.note_store.createNote, note)
def test_sync_exception_while_download_retry(cli_invoker, mock_evernote_client,
fake_storage, mocker):
mock_evernote_client.fake_notebooks.append(
Notebook(
guid="nbid1",
name="name1",
stack="stack1",
serviceUpdated=1000,
), )
test_notes = [
Note(
guid=f"id{i}",
title="test",
content="test",
notebookGuid="nbid1",
contentLength=100,
active=True,
) for i in range(10)
]
mock_evernote_client.fake_notes.extend(test_notes)
retry_count = 3
def fake_get_note(note_guid):
nonlocal retry_count
if note_guid == "id3" and retry_count > 0:
retry_count -= 1
raise struct.error
return Note(
guid=note_guid,
title="test",
content="test",
notebookGuid="nbid1",
contentLength=100,
active=True,
)
mock_get_note = mocker.patch(
"evernote_backup.evernote_client_sync.EvernoteClientSync.get_note")
mock_get_note.side_effect = fake_get_note
cli_invoker("sync", "--database", "fake_db")
result_notes = list(fake_storage.notes.iter_notes("nbid1"))
assert set(result_notes) == set(test_notes)
def test_sync_add_linked_notebook_note_with_tag(cli_invoker,
mock_evernote_client,
fake_storage):
mock_evernote_client.fake_l_notebooks.append(
Notebook(
guid="nbid1",
name="name1",
), )
mock_evernote_client.fake_l_tags = [
Tag(guid="tid1", name="tag1"),
Tag(guid="tid2", name="tag2"),
]
mock_evernote_client.fake_l_notes.append(
Note(
guid="id1",
title="title1",
content="body1",
notebookGuid="nbid1",
active=True,
contentLength=100,
tagGuids=["tid1", "tid2"],
))
expected_notes = [
Note(
guid="id1",
title="title1",
content="body1",
notebookGuid="nbid1",
active=True,
contentLength=100,
tagGuids=["tid1", "tid2"],
tagNames=["tag1", "tag2"],
)
]
mock_evernote_client.fake_linked_notebooks.append(
LinkedNotebook(guid="id3", shardId="s100"))
mock_evernote_client.fake_linked_notebook_auth_token = (
"S=200:U=ff:E=fff:C=ff:P=1:A=test222:V=2:H=ff")
cli_invoker("sync", "--database", "fake_db")
result_notes = list(fake_storage.notes.iter_notes("nbid1"))
assert result_notes == expected_notes
def test_sync_add_linked_notebook_stack(cli_invoker, mock_evernote_client,
fake_storage):
mock_evernote_client.fake_l_notebooks.append(
Notebook(
guid="nbid1",
name="name1",
), )
mock_evernote_client.fake_linked_notebooks.append(
LinkedNotebook(guid="id3", stack="test_stack"))
expected_notebooks = [
Notebook(
guid="nbid1",
name="name1",
stack="test_stack",
)
]
cli_invoker("sync", "--database", "fake_db")
result_notebooks = list(fake_storage.notebooks.iter_notebooks())
assert result_notebooks == expected_notebooks
def test_sync_nothing_to_sync(cli_invoker, mock_evernote_client, fake_storage):
mock_evernote_client.fake_notebooks.append(
Notebook(
guid="id1",
name="name1",
stack="stack1",
), )
fake_storage.config.set_config_value("USN", mock_evernote_client.fake_usn)
cli_invoker("sync", "--database", "fake_db")
result_notebooks = list(fake_storage.notebooks.iter_notebooks())
assert not result_notebooks
def test_sync_add_note_with_tags(cli_invoker, mock_evernote_client,
fake_storage):
mock_evernote_client.fake_tags = [
Tag(guid="tid1", name="tag1"),
Tag(guid="tid2", name="tag2"),
]
mock_evernote_client.fake_notebooks.append(
Notebook(
guid="nbid1",
name="name1",
stack="stack1",
serviceUpdated=1000,
), )
mock_evernote_client.fake_notes.append(
Note(
guid="id1",
title="title1",
content="body1",
notebookGuid="nbid1",
active=True,
contentLength=100,
tagGuids=["tid1", "tid2"],
))
expected_notes = [
Note(
guid="id1",
title="title1",
content="body1",
notebookGuid="nbid1",
active=True,
contentLength=100,
tagGuids=["tid1", "tid2"],
tagNames=["tag1", "tag2"],
)
]
cli_invoker("sync", "--database", "fake_db")
result_notes = list(fake_storage.notes.iter_notes("nbid1"))
assert result_notes == expected_notes
def notify(title, message,
access_token=None,
notebook='ntfy-notifications',
sandbox=False, china=False,
**_):
try:
client = EvernoteClient(
consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
token=access_token,
sandbox=sandbox, china=china
)
if not client.token:
login(client=client)
if not client.token:
print(f'Skiped with not login.')
return 1
noteStore = client.get_note_store()
nbs = noteStore.listNotebooks()
nb = ([x for x in nbs if x.name == notebook] + [None])[0]
if nb is None:
nb = Notebook(name=notebook)
nb = noteStore.createNotebook(nb)
note = Note(notebookGuid=nb.guid)
note.title = str(title)
note.content = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">'
note.content += f'<en-note>{escape(message)}</en-note>'
noteStore = client.get_note_store()
note = noteStore.createNote(note)
except EDAMUserException as ue:
if ue.errorCode == EDAMErrorCode.RATE_LIMIT_REACHED:
print(f'Rate limit reached, Retry your request in {ue.rateLimitDuration} seconds')
return 1
else:
raise
def main():
client = EvernoteClient(token=dev_token, sandbox=False)
noteStore = client.get_note_store()
noteStore = client.get_note_store()
Filter=NodeTypes.NoteFilter()
Filter.words = 'tag:@smarttodo'
notes = noteStore.findNotes(dev_token, Filter, 0, 10)
for note in notes.notes:
nt = noteStore.getNote(dev_token, note.guid, True, False, False, False)
root = ElementTree.fromstring(nt.content)
ElementTree.dump(root)
sections = split_into_sections(root)
today = datetime.date.today() - datetime.timedelta(1)
tomorrow = today + datetime.timedelta(1)
conversions = {
'today': today,
'tomorrow': tomorrow,
'yesterday': today - datetime.timedelta(1),
}
print sections
unfinished = parse_out_due_dates(sections['today'][1:], today, conversions,
sections['settings']['Date format'])
unfinished.extend(
parse_out_due_dates(sections['later'][1:], tomorrow, conversions,
sections['settings']['Date format']))
new_today_list = [x for x in unfinished if x[0] <= tomorrow]
new_tomorrow_list = [x for x in unfinished if x[0] > tomorrow]
new_tomorrow_list.sort(key=lambda x: x[0])
sections['today'][1:] = update_tasks(new_today_list, sections['settings']['Date format'], sections['settings']['Date separator'])
sections['later'][1:] = update_tasks(new_tomorrow_list, sections['settings']['Date format'], sections['settings']['Date separator'])
text, tail, attrib, tag = root.text, root.tail, root.attrib, root.tag
root.clear()
root.text, root.tail, root.attrib, root.tag = text, tail, attrib, tag
for sec in ['start', 'today', 'later', 'end']:
for section in sections[sec]:
if sec in ['today', 'later']:
root.extend(section)
else:
root.append(section)
while len(root) > 0 and root[-1].tag == 'br':
root.remove(root[-1])
new_node_content = ElementTree.tostring(root, 'utf-8')
nt.content = content_prefix + new_node_content
print 'Updated:'
ElementTree.dump(root)
noteStore.updateNote(dev_token, nt)
if len(sections['completed']) <= 0:
continue
history_notebook = sections['settings']['History notebook'].strip()
history_interval = sections['settings']['History interval'].strip()
history_prefix = sections['settings']['History note'].strip()
history_title = get_history_note_title(history_prefix, today,
history_interval,
sections['settings']['Date format'],
sections['settings']['Date separator'])
notebooks = noteStore.listNotebooks(dev_token)
notebook_guid = None
for notebook in notebooks:
if notebook.name == history_notebook:
notebook_guid = notebook.guid
if notebook_guid == None:
notebook = Notebook()
notebook.name = history_notebook
notebook = noteStore.createNotebook(dev_token, notebook)
notebook_guid = notebook.guid
Filter = NodeTypes.NoteFilter()
Filter.notebookGuid = notebook_guid
Filter.words = 'intitle:' + history_title
history_notes = noteStore.findNotes(dev_token, Filter, 0, 1)
if len(history_notes.notes) < 1:
hist_root = ElementTree.Element('en-note')
hist_note = Note()
hist_note.title = history_title
hist_note.notebookGuid = notebook_guid
else:
hist_note = noteStore.getNote(dev_token, history_notes.notes[0].guid,
True, False, False, False)
hist_root = ElementTree.fromstring(hist_note.content)
day_element = ElementTree.fromstring('<div><strong>{}</strong></div>'.format(
date_to_string(today,
sections['settings']['Date format'],
sections['settings']['Date separator'])))
hist_root.append(day_element)
for x in sections['completed']:
hist_root.extend(x)
hist_note.content = content_prefix + ElementTree.tostring(hist_root, 'utf-8')
if len(history_notes.notes) < 1:
noteStore.createNote(dev_token, hist_note)
else:
noteStore.updateNote(dev_token, hist_note)