def getToDos(day):
dev_token = getToken(False)
client = EvernoteClient(token=dev_token, sandbox=False)
notestore = client.get_note_store()
ToDoTags = getToDoTags(dev_token, notestore)
dayGuid = getDayTag(day, notestore)
myfilter = NoteFilter()
spec = NotesMetadataResultSpec()
spec.includeTitle = True
mylist = []
noteguids = {}
TODOLIST = dict()
notebody = ""
for tag, guid in ToDoTags.iteritems():
mylist = []
mylist.append(guid)
mylist.append(dayGuid)
myfilter.tagGuids = mylist
notes = notestore.findNotesMetadata(dev_token, myfilter, 0, 100, spec)
TODOLIST[tag] = []
for note in notes.notes:
TODOLIST[tag].append(note.title)
return TODOLIST
def search(self, fp):
fl = NoteFilter(order=NoteSortOrder.UPDATED)
fl.words = 'intitle:"%s"' % fp
sp = NotesMetadataResultSpec(includeTitle=True)
result = self.ns.findNotesMetadata(self.tk, fl, 0, 1, sp).notes
if result:
return result[0].guid
return False
def get_notes(self, *tag_names):
"""Return a list of notes matching the tag_names"""
note_filter = NoteFilter()
note_filter.tagGuids = [self.tags[tn].guid for tn in tag_names if tn]
result_spec = NotesMetadataResultSpec()
result_spec.includeTitle = True
result_spec.includeTagGuids = True
notes = self.note_store.findNotesMetadata(note_filter, 0, 100, result_spec)
for note in notes.notes:
yield note
def getNotesInNotebook(self, wanted_notebook):
filter = NoteFilter()
updated_filter = NoteFilter(words='evernote')
filter.notebookGuid = wanted_notebook.guid;
offset = 0
max_notes = 10
result_spec = NotesMetadataResultSpec(includeTitle=True)
#notes = note_store.findNotes(auth_token, filter, offset, max_notes);
notes_data = self.note_store.findNotesMetadata(auth_token, filter, offset, max_notes, result_spec);
notes = notes_data.notes
return notes
def find_notes_filter_by_tag_guids(self, guids_list):
evernote_filter = NoteFilter()
evernote_filter.ascending = False
evernote_filter.tagGuids = guids_list
spec = NotesMetadataResultSpec()
spec.includeTitle = True
note_list = self.noteStore.findNotesMetadata(self.token, evernote_filter, 0, 10000, spec)
guids = []
for note in note_list.notes:
guids.append(note.guid)
return guids
def listar_notes(self):
note_store = self.client.get_note_store()
filter = NoteFilter()
filter.word = "notebook:Faculdade"
spec = NotesMetadataResultSpec()
spec.includeTitle = True
all_notes = note_store.findNotesMetadata(self.dev_token, filter, 0, 10, spec)
for note in all_notes.notes:
print(note.title)
conteudo = note_store.getNoteContent(note.guid)
print(conteudo)
def process_goal_updates(self, stored_goal_states):
note_filter = NoteFilter()
# Get all the goals
for notebook in self.get_note_store().listNotebooks():
if notebook.name not in ["Backlog","Current","Complete","Dropped"]:
continue
note_filter.notebookGuid = notebook.guid
note_metadata_list = self.get_all_notes_metadata(self.auth_token,note_filter,NoteStore.NotesMetadataResultSpec())
# For each goal
for note_metadata in note_metadata_list:
# Check if the goal is new or has changed state (moved from another notebook)
if note_metadata.guid in stored_goal_states[notebook.name]:
# the goal is in the same state as it was the last time we checked
continue
else:
# the goal is new, or it has changed state
# search to see if it was previously in a different notebook
other_notebooks = ["Backlog","Current","Complete","Dropped"]
other_notebooks.remove(notebook.name)
goal_has_moved = None
for previous_notebook in other_notebooks:
if note_metadata.guid in stored_goal_states[previous_notebook]:
# We know the note used to be in this notebook, so annotate the note and update what we know
annotation = (datetime.now()-timedelta(days=1)).strftime("%Y-%m-%d") \
+ " Moved from " + previous_notebook \
+ " to " + notebook.name
self.annotate_note(note_metadata.guid,annotation,False)
stored_goal_states[previous_notebook].remove(note_metadata.guid)
stored_goal_states[notebook.name].append(note_metadata.guid)
goal_has_moved = True
break
if goal_has_moved is None:
# The note has been newly added
# So annotate the note and save the state of the note locally
annotation = (datetime.now()-timedelta(days=1)).strftime("%Y-%m-%d") \
+ " Added to " + notebook.name
self.annotate_note(note_metadata.guid,annotation,True)
stored_goal_states[notebook.name].append(note_metadata.guid)
return stored_goal_states
def getnotes(self,auth_token, nb_guid, fun):
spec = NotesMetadataResultSpec()
spec.includeTitle=True
filter=NoteFilter()
filter.notebookGuid=nb_guid
note_store = self.client.get_note_store()
notelist = []
for i in range(0,500,250):
notes = note_store.findNotesMetadata(auth_token, filter, i, i+250, spec)
notelist.extend([fun(n) for n in notes.notes])
return notelist
def getnotes(self, auth_token, nb_guid, fun):
spec = NotesMetadataResultSpec()
spec.includeTitle = True
filter = NoteFilter()
filter.notebookGuid = nb_guid
note_store = self.client.get_note_store()
notelist = []
for i in range(0, 500, 250):
notes = note_store.findNotesMetadata(auth_token, filter, i,
i + 250, spec)
notelist.extend([fun(n) for n in notes.notes])
return notelist
def find_notes_filter_by_tag_guids(self, guids_list):
evernote_filter = NoteFilter()
evernote_filter.ascending = False
evernote_filter.tagGuids = guids_list
spec = NotesMetadataResultSpec()
spec.includeTitle = True
note_list = self.noteStore.findNotesMetadata(self.token,
evernote_filter, 0, 10000,
spec)
guids = []
for note in note_list.notes:
guids.append(note.guid)
return guids
def get_tip_notes(start_date, end_date): tip_notes = [] noteFilter = NoteFilter() noteFilter.words = "tag:tip created:%s -created:%s" % (start_date, end_date) # notes with tag #tip created between 2012-01-01 and 2014-09-08 (flight dates) note_list = note_store.findNotes(auth_token, noteFilter, 0, 10) for note in note_list.notes: guid = note.guid title = note.title url = "evernote:///view/8f65c/s1/%s/%s/" % (guid, guid) tip_notes.append( '<div><en-todo/> %s (<a href="%s">view full note</a>)</div>' % (title, url) ) return tip_notes
def list_notes(self, notebook):
# ノート検索条件を指定。ノートブックのIDを指定。更新日でソート
note_filter = NoteFilter()
note_filter.notebookGuid = notebook.guid
note_filter.order = NoteSortOrder.UPDATED
# ノート検索結果のフォーマットを指定。タイトルを含む
result_format = NotesMetadataResultSpec()
result_format.includeTitle = True
# ノートのメタデータリストを取得
note_meta_list = self.note_store.findNotesMetadata(note_filter, 0, 10, result_format)
return [Note(self, note_meta) for note_meta in note_meta_list.notes]
def load_notes(note_store,accessToken,type,guid,display):
# Connecting to Evernote
notes = []
offset = 0
maxNotes = 100
# Creating NoteFilter
if (type == "search"):
noteFilter = NoteFilter(order=NoteSortOrder.UPDATED,words=guid)
elif (type == "tag"):
noteFilter = NoteFilter(order=NoteSortOrder.UPDATED,tagGuids=[guid])
else:
noteFilter = NoteFilter(order=NoteSortOrder.UPDATED,notebookGuid=guid)
if int(display) == safeglobals.NOTES_ENCRYPTED_ONLY:
noteFilter.words = safeglobals.ENCRYPTED_PREFIX[:-2]
elif int(display) == safeglobals.NOTES_UNENCRYPTED_ONLY:
noteFilter.words = "-%s" % safeglobals.ENCRYPTED_PREFIX[:-2]
# Creating ResultSpec
result_spec = NotesMetadataResultSpec(includeTitle=True,includeCreated=True,includeUpdated=True,includeNotebookGuid=True)
# Getting the result
response = note_store.findNotesMetadata(accessToken, noteFilter, offset, maxNotes, result_spec)
# Parsing the list of NotesMetadata
for metadata in response.notes:
notes.append({"guid":metadata.guid,"updated":millisToDate(metadata.updated),"created":millisToDate(metadata.created),"title":metadata.title})
# Caching notes
cache_notes(notes,type,guid)
return notes
def sync_notebook_notes(self, notebook):
if not self.should_sync_notebook_notes(notebook):
return
logging.info('sync notebook: ' + notebook.name)
note_filter = NoteFilter()
note_filter.notebookGuid = notebook.guid
note_list = []
current_offset = 0
while True:
logging.info('sync notebook: ' + notebook.name + ' - ' +
str(current_offset))
note_batch = self.note_store.findNotes(note_filter, current_offset,
NOTES_LOAD_BATCH_SIZE + 1)
if len(note_batch.notes) < NOTES_LOAD_BATCH_SIZE + 1:
note_list += note_batch.notes
break
else:
note_list += note_batch.notes[:-1]
current_offset += NOTES_LOAD_BATCH_SIZE
if notebook.guid in self.notebook_notes:
prev_notes = self.notebook_notes[notebook.guid].copy()
else:
prev_notes = {}
new_notes = {}
for note in note_list:
new_notes[note.guid] = note
if note.guid not in prev_notes:
logging.info('sync new note: ' + note.title)
self.add_notebook_note_to_fuse(note)
elif note.title != prev_notes[note.guid].title:
logging.info('sync note renamed: ' +
prev_notes[note.guid].title + '->' + note.title)
self.rename_notebook_note_in_fuse(note.notebookGuid,
prev_notes[note.guid].title,
note.title)
for prev_note_guid, prev_note in prev_notes.items():
if prev_note_guid not in new_notes:
logging.info('sync: note deleted: ' + prev_note.name)
self.remove_notebook_note_from_fuse(prev_note.notebookGuid,
prev_note_guid)
self.notebook_notes[notebook.guid] = new_notes
logging.info('sync notebook - done: ' + notebook.name)
self.notebooks_notes_sync_time[notebook.guid] = time()
def get_notes(userStore, noteStore):
guid = get_site_notebook().guid
published_guid = get_published_tag(guid)
note_filter = NoteFilter()
note_filter.notebookGuid = guid
note_filter.order = NoteSortOrder.CREATED
note_filter.tagGuids = [published_guid]
spec = NotesMetadataResultSpec(includeTitle=True,
includeCreated=True,
includeUpdated=True,
includeNotebookGuid=True,
includeTagGuids=True)
notes = noteStore.findNotesMetadata(note_filter, 0, 100, spec).notes
return notes
def searchNote(client, note_store, notebooks, notebookname, notename):
# 対象のノートブックを検索
copied_notebook_guid = None
for notebook in notebooks:
if notebook.name == notebookname:
copied_notebook_guid = notebook.guid
break
# 該当するノートブックが存在しない場合にはエラー
if copied_notebook_guid == None:
return "", ""
# 対象のノートを検索
offset = 0
max_notes = 400
filter = NoteFilter(notebookGuid=copied_notebook_guid)
result_spec = NotesMetadataResultSpec(includeTitle=True)
result_list = note_store.findNotesMetadata(EVERNOTE_DEV_TOKEN, filter,
offset, max_notes, result_spec)
copied_note_guid = None
for note in result_list.notes:
if note.title == notename:
copied_note_guid = note.guid
break
# 該当するノートが存在しない場合にはエラー
if copied_note_guid == None:
return "", ""
return copied_notebook_guid, copied_note_guid
def get_notes():
auth_token = request.args.get('auth_token')
if not auth_token:
return
notebook = request.args.get('notebook')
if not notebook:
return
client = EvernoteClient(token=auth_token)
note_store = client.get_note_store()
offset = 0
max_notes = 1000
filter = NoteFilter(order=Types.NoteSortOrder.UPDATED,
notebookGuid=notebook)
result_spec = NotesMetadataResultSpec(includeTitle=True)
metadata = note_store.findNotesMetadata(auth_token, filter, offset,
max_notes, result_spec)
notes = []
for n in metadata.notes:
content = note_store.getNoteContent(auth_token, n.guid)
notes.append({
'guid': n.guid,
'content': unicode(ENMLToHTML(content)),
'title': n.title
})
return jsonify(notes=notes)
def view_notebook_detail(request):
if request.method == "POST":
notes_values = ""
try:
user_obj = User.objects.get(username=request.user.get_username())
evernote_token = user_obj.evernotecredential.evernote_token
client = get_evernote_client(evernote_token)
note_store = client.get_note_store()
userStore = client.get_user_store()
updated_filter = NoteFilter(
notebookGuid=request.POST.get("guid_", ""))
offset = 0
max_notes = 10
result_spec = NotesMetadataResultSpec(includeTitle=True)
notes = note_store.findNotesMetadata(updated_filter, offset,
max_notes, result_spec)
notes_values = notes.notes
except Exception as e:
print "{}:{}".format(e.args, e.message)
raise
return render(
request, 'notes.html', {
'notes': notes_values,
'notebook_id': request.POST.get("guid_", ""),
'username': request.user.get_username()
})
def get_todo_note_guids(session):
# Evernote's Note Store object is the access point to all note-related
# information
auth_token = session['en_identifier']
note_store = enauth.get_notestore(session)
all_tags = note_store.listTags(auth_token) # get the todo tag guid
todo_guid = [tag for tag in all_tags if tag.name == "todo"][0].guid
note_filter = NoteFilter() # the notefilter object allows us to define filters for our eventual findNotesMetadata call
note_filter.tagGuids = [todo_guid] # find note with todo guid (ie, the todo note)
offset, max_notes = 0, 10
result_spec = NotesMetadataResultSpec(includeTitle=True) # allows us to request specific info be returned about the note
result_list = note_store.findNotesMetadata(auth_token, note_filter, offset, max_notes, result_spec)
return note_store, [note.guid for note in result_list.notes]
def search_notes(self, words):
filter = NoteFilter(words=words)
spec = NotesMetadataResultSpec()
spec.includeTitle = True
note_list = self.note_store.findNotesMetadata(self.token, filter, 0,
100, spec)
return note_list
def list_notes(note_store, notebook):
filter = NoteFilter(notebookGuid=notebook.guid)
spec = NotesMetadataResultSpec(includeTitle=True,
includeContentLength=True,
includeCreated=True,
includeUpdated=True)
notes = []
offset = 0
remain = EDAM_USER_NOTES_MAX
while remain > 0:
notes_list = note_store.findNotesMetadata(filter, offset, remain, spec)
# See http://dev.evernote.com/doc/reference/NoteStore.html#Struct_NotesMetadataList
remain = notes_list.totalNotes - (notes_list.startIndex +
len(notes_list.notes))
offset += len(notes_list.notes)
notes.extend(notes_list.notes)
for note in notes:
created_time = datetime.datetime.fromtimestamp(note.created *
TIMESTAMP_RESOLUTION)
updated_time = datetime.datetime.fromtimestamp(note.updated *
TIMESTAMP_RESOLUTION)
title = note.title.decode('utf-8')
print(u' {} ({}) ctime={} mtime={}'.format(title, note.guid,
created_time,
updated_time))
def defaultSearchFilter(self, notebook):
# `order = 1' -> order by created
# `order = 2' -> order by updated
# @see NoteStoreOrder at https://dev.evernote.com/doc/reference/Types.html
searchFilter = NoteFilter(order=2,
ascending=False,
notebookGuid=notebook.guid)
return searchFilter
def iterate_through_evernote(evernote_lists,noteStore,google_lists,google_auth): evernote_dev_token = 'S=s317:U=2a12764:E=14524e2f945:C=13dcd31cd47:P=1cd:A=en-devtoken:V=2:H=4ae170cd15a53f88d0b2150c23fcae0b' notebooks = noteStore.listNotebooks() for i in notebooks: filter = NoteFilter() filter.notebookGuid = i.guid notes = noteStore.findNotes(evernote_dev_token,filter,0,100) notebook_name = '' if i.name == "gophersbball17's notebook": notebook_name = "testing55318's list" else: notebook_name = i.name google_guid = google_lists[1][google_lists[0].index(notebook_name)] gList = get_google_list_items(google_guid) for n in notes.notes: if n.title not in gList: create_google_list_item(google_guid,n.title,google_auth)
def process_notebook(notebook, note_store, user):
print_info("Processing notebook:" + notebook.name)
note_filter = NoteFilter(order=NoteSortOrder.TITLE)
note_filter.notebookGuid = notebook.guid
result_spec = NotesMetadataResultSpec(includeTitle=True)
result_list = note_store.findNotesMetadata(note_filter, 0, MAX_NOTES, result_spec)
notes = []
for note in result_list.notes:
notes.append({
'title': note.title,
'link': generate_note_link(user, note)
})
return notes
def runBackup(self):
self.initClient()
notebooks = self.noteStore.listNotebooks(self.token)
notebookIndex = 0
for notebook in notebooks:
self.progressHandler.startTask('Backing up notebook ' +
notebook.name)
filt = NoteFilter()
filt.notebookGuid = notebook.guid
notelist = self.noteStore.findNotes(self.token, filt, 0, 100)
if not len(notelist.notes): continue
notes = []
self.progressHandler.startTask('Notebook: ' + notebook.name)
i = 0
for note in notelist.notes:
i += 1
notes.append(self.getNote(notebook.name, note.guid))
notesProgress = float(i) / len(notelist.notes) / len(notebooks)
notebookProgress = float(notebookIndex) / len(notebooks)
self.progressHandler.setProgress(notesProgress +
notebookProgress)
if self.add_note_files:
for note in notes:
filename = note['title'] + '.xml'
self.output.set(filename,
note['content_raw'],
bucket=notebook.name + '/notes')
if self.create_json:
jsonData = json.dumps(notes)
self.output.set('data.json', jsonData, bucket=notebook.name)
if self.create_csv:
self.writeCsvData(notebook.name, 'data.csv', notes)
notebookIndex += 1
def get_notes_with_tag(self, tag):
""" Gets all the notes with the tag "tag"
"""
notestore = self._get_note_store()
allTags = notestore.listTags(self.oauth_token)
tag = [x for x in allTags if x.name == tag][0]
nFilter = NoteFilter(tagGuids=[tag.guid])
notes = notestore.findNotes(self.oauth_token, nFilter, 0, 10)
return notes.notes
def find_note(keywords):
"""
Find note content by keyword.
:param keywords: (str) keyword for search.
:return: (str) first result content.
"""
from evernote.edam.notestore.ttypes import NoteFilter, NotesMetadataResultSpec
dev_token, note_store = connect_note()
search = NoteFilter()
search.words = keywords
search.ascending = False
spec = NotesMetadataResultSpec()
spec.includeTitle = True
our_note_list = note_store.findNotesMetadata(dev_token, search, 0, 100, spec)
note_content = note_store.getNoteContent(dev_token, our_note_list.notes[0].guid)
return note_content
def get_evernote_list_items(noteStore):
evernote_dev_token = 'S=s317:U=2a12764:E=14524e2f945:C=13dcd31cd47:P=1cd:A=en-devtoken:V=2:H=4ae170cd15a53f88d0b2150c23fcae0b'
dict = {}
notebooks = noteStore.listNotebooks()
for i in notebooks:
filter = NoteFilter()
filter.notebookGuid = i.guid
notes = noteStore.findNotes(evernote_dev_token,filter,0,100)
notebook_name = ''
if i.name == "gophersbball17's notebook":
notebook_name = "testing55318's list"
else:
notebook_name = i.name
note_names = [i.guid]
for n in notes.notes:
note_names.append(n.title)
dict[notebook_name] = note_names
return dict
def getFirstNoteBook():
userStore = client.get_user_store()
noteStore = client.get_note_store()
note = noteStore.listNotebooks()
user = userStore.getUser()
firstNotebook = note[0]
global firstID
firstID = firstNotebook.guid
print (" ")
print ("First notebook in the stack")
print firstNotebook.name
print firstID
print (" ")
print " Notes in " + firstNotebook.name
# filter = NoteFilter()
# filter.notebookGuid = firstID
# filter.order = Types.NoteSortOrder.UPDATED
# filter.ascending = False
updated_filter = NoteFilter(order=NoteSortOrder.UPDATED)
updated_filter.notebookGuid = firstID
offset = 0
max_notes = 10
result_spec = NotesMetadataResultSpec(includeTitle=True)
result_list = noteStore.findNotesMetadata(dev_token, updated_filter, offset, max_notes, result_spec)
# note is an instance of NoteMetadata
# result_list is an instance of NotesMetadataList
for note in result_list.notes:
print note.title
notesContents[note.title] = noteStore.getNoteContent(note.guid)
allNotes.append(note)
print (" ")
print ("Username")
print user.username
def get_ev_notes():
dev_token = app.config['EN_DEV_TOKEN']
notestore_url = app.config['EN_NOTESTORE_URL']
nb_guid = app.config['EN_NB_GUID']
client = EvernoteClient(token=dev_token)
note_store = client.get_note_store()
filt = NoteFilter()
filt.notebookGuid = nb_guid
spec = NotesMetadataResultSpec()
spec.includeTitle = True
notemetalist = note_store.findNotesMetadata(dev_token, filt, 0, 100, spec)
notes = []
for note_data in notemetalist.notes:
note = note_store.getNote(dev_token, note_data.guid, True, True, True,
True)
title = note.title
author = note.attributes.author
date = note.updated
url = note.attributes.sourceURL
cont = note.content
note_tags = []
tag_guids = note.tagGuids
if tag_guids is not None:
for tag_guid in tag_guids:
tag = note_store.getTag(dev_token, tag_guid)
note_tags.append({'guid': tag_guid, 'name': tag.name})
notes.append({
'guid': note_data.guid,
'title': title,
'date_modified': date,
'author': author,
'content': cont,
'tags': note_tags
})
#print notes
return dumps(notes)
def __get_all_notes_metadata_from_notebook(self, notebook_guid, note_store,
token):
notes_filter = NoteFilter(notebookGuid=notebook_guid)
spec = NotesMetadataResultSpec()
spec.includeTitle = True
allNotesFromNotebook = note_store.findNotesMetadata(
token, notes_filter, 0, 250, spec)
return allNotesFromNotebook.notes
def retrieve_note_content(self):
note_filter = NoteFilter(order=2,
notebookGuid=self.get_notebook_guid())
result_spec = NotesMetadataResultSpec(includeTitle=True)
notesMetadata = self._note_store.findNotesMetadata(
note_filter, 0, 1, result_spec)
if notesMetadata.notes:
note_guid = notesMetadata.notes[0].guid
return self._note_store.getNoteContent(note_guid)
return 'ERROR: There are no notes in the notebook.'
def runBackup(self):
self.initClient()
notebooks = self.noteStore.listNotebooks(self.token)
notebookIndex = 0
for notebook in notebooks:
self.progressHandler.startTask('Backing up notebook ' + notebook.name)
filt = NoteFilter()
filt.notebookGuid = notebook.guid
notelist = self.noteStore.findNotes(self.token, filt, 0, 100)
if not len(notelist.notes): continue
notes = []
self.progressHandler.startTask('Notebook: ' + notebook.name)
i = 0
for note in notelist.notes:
i += 1
notes.append(self.getNote(notebook.name, note.guid))
notesProgress = float(i) / len(notelist.notes) / len(notebooks)
notebookProgress = float(notebookIndex) / len(notebooks)
self.progressHandler.setProgress(notesProgress + notebookProgress)
if self.add_note_files:
for note in notes:
filename = note['title'] + '.xml'
self.output.set(filename, note['content_raw'],
bucket=notebook.name + '/notes')
if self.create_json:
jsonData = json.dumps(notes)
self.output.set('data.json', jsonData, bucket=notebook.name)
if self.create_csv:
self.writeCsvData(notebook.name, 'data.csv', notes)
notebookIndex += 1
def _process_notes(self, notebook_guid):
"""process notes in given notebook checking if any need to be synced to backup location"""
note_filter = NoteFilter()
note_filter.notebookGuid = notebook_guid
result_spec = NotesMetadataResultSpec()
# evernote api will return None for almost all fields unless set them on in metadata
result_spec.includeTitle = True
result_spec.includeUpdated = True
offset = 0
notes = self.note_store.findNotesMetadata(self.token, note_filter, offset, 250, result_spec)
while offset < notes.totalNotes:
for en in notes.notes:
# only fetch actual note if has been updated since last time
if en.guid not in self.tracking or en.updated != self.tracking[en.guid]:
note = self._create_note(en.guid)
self._save(note)
offset += 250
notes = self.note_store.findNotesMetadata(self.token, note_filter, offset, 250, result_spec)
print 'synced %i notes to %s' % (self.cnt, self.local_dir)
self.logger.info('synced %i notes to %s' % (self.cnt, self.local_dir))
def search(self, title=None, max_results=1):
""" bumble through evernote's weird api to find a note. """
if title:
title = "intitle:'{title}'".format(title=title)
notefilter = NoteFilter(order=NoteSortOrder.UPDATED, words=title)
finder = self.store.findNotesMetadata(notefilter, 0, max_results,
NotesMetadataResultSpec())
notes = finder.notes
if notes:
return [note.guid for note in finder.notes]
def find_note(keywords):
"""
Find note content by keyword.
:param keywords: (str) keyword for search.
:return: (str) first result content.
"""
from evernote.edam.notestore.ttypes import NoteFilter, NotesMetadataResultSpec
dev_token, note_store = connect_note()
search = NoteFilter()
search.words = keywords
search.ascending = False
spec = NotesMetadataResultSpec()
spec.includeTitle = True
our_note_list = note_store.findNotesMetadata(dev_token, search, 0, 100,
spec)
note_content = note_store.getNoteContent(dev_token,
our_note_list.notes[0].guid)
return note_content
def get_note_dict_in_tag(self, tagname):
tags = self.note_store.listTags(self.auth_token)
tag_guid = None
for t in tags:
if t.name == tagname:
tag_guid = t.guid
if not tag_guid:
raise NameError("tag not found " + tagname)
return self.get_note_dict_in_filterlist(
[NoteFilter(tagGuids=[tag_guid])])
def retrieve_note(self):
note_filter = NoteFilter(order=2,
notebookGuid=self.get_notebook_guid())
result_spec = NotesMetadataResultSpec(includeTitle=True)
notesMetadata = self._note_store.findNotesMetadata(
note_filter, 0, 1, result_spec)
if notesMetadata.notes:
note_guid = notesMetadata.notes[0].guid
retrieved_note = self._note_store.getNote(note_guid, False, False,
True, False)
for resource in retrieved_note.resources:
print resource
def default_notbook():
authToken = session['identifier']
noteStore = get_notestore()
notebooks = noteStore.listNotebooks(authToken)
for notebook in notebooks:
defaultNotebook = notebook
break
nfilter = NoteFilter()
nfilter.notebookGuid = defaultNotebook.guid
result_spec = NotesMetadataResultSpec(includeTitle=True)
notes = noteStore.findNotesMetadata(authToken, nfilter, 0, 100, result_spec)
print notes
for note in notes.notes:
if note.guid == "e00c1b8b-cc4f-48b5-bdbb-5f6069dbbc4a":
fullnote = noteStore.getNote(authToken,note.guid,True,True,True,True)
resources = fullnote.resources
syncState = noteStore.getSyncState(authToken)
mergeByTimeStamp()
return resources[0].guid
def getsContent(self, limit):
self.getsNoteBooks()
# 取最近4条笔记
article_list = {}
for guid, _ in self.notebook_guids.items():
searchfilter = NoteFilter(notebookGuid=guid)
offset = 0
article_list[guid] = self.note_store.findNotes(
searchfilter, offset, limit)
if not bool(article_list):
#print(notebookname+"的笔记本中没有数据")
return False
return_data = []
for notebook_guid, notebook_article in article_list.items():
for row in notebook_article.notes:
data = {}
if True != row.active: continue
data["deleted"] = row.deleted # None or True
data["guid"] = row.guid
data["title"] = row.title
data["content"] = row.content
data["created"] = formatDate(row.created)
data["updated"] = formatDate(row.updated)
content = self.note_store.getNoteContent(row.guid)
content = xml2Html(content)
data["notebook_guid"] = notebook_guid
data["notebook_name"] = self.notebook_guids[notebook_guid]
data["content"] = content
return_data.append(data)
if None != row.resources:
for image in row.resources:
suffix = image.mime[image.mime.find("/") + 1:]
'''
print(image.width)
print(image.height)
'''
#生成图片
binary_data = self.note_store.getResourceData(
image.guid)
file_name = hashlib.md5(binary_data).hexdigest()
file_path = "./html/upload/" + file_name + "." + suffix
image = open(file_path, 'wb')
image.write(bytes(binary_data))
image.close()
return_data = sorted(return_data,
key=lambda keys: keys['created'],
reverse=True)
return return_data
def main(argv):
print 'starting the python process'
# the list of already entered images
guidList = []
# Evernote login credentials
dev_token = "S=s1:U=8fb0e:E=150ba27eb99:C=1496276bc48:P=1cd:A=en-devtoken:V=2:H=cb6610893ef12aa4b914d15d19befa09"
client = EvernoteClient(token=dev_token, sandbox=True)
NoteStore = client.get_note_store()
filterNote = NoteFilter(order=NoteSortOrder.UPDATED)
filterNote.notebookGuid = 'cdbc8617-c551-4148-b659-7ccb5d47859e'
searchResults = NoteStore.findNotes(filterNote, 0, 20)
for note in searchResults.notes:
if note.resources != None:
for r in note.resources:
# save each livescribe file and add the guid to the list
try:
guidList.append(save_files(NoteStore, r.guid))
except:
print 'Unexpected error when saving original files:', sys.exc_info()[0]
raise
# now you start the evernote listening thread
while(True):
newNote = NoteStore.findNotes(filterNote, 0, 1)
for note in newNote.notes:
if note.resources != None:
try:
for r in note.resources:
if not (r.guid in guidList):
guidList.append(save_files(NoteStore, r.guid))
print 'found new image:', r.guid, 'going to sleep for 10 seconds'
time.sleep(10)
else:
print 'no new images - going to sleep for 20 seconds'
time.sleep(20)
except:
print 'Unexpected error when looping:', sys.exc_info()[0]
raise
def get_all_notes_in_notebook(notebook):
guid = notebook.guid
filter = NoteFilter(notebookGuid=guid)
#def __init__(self, includeTitle=None, includeContentLength=None, includeCreated=None, includeUpdated=None, includeDeleted=None, includeUpdateSequenceNum=None, includeNotebookGuid=None, includeTagGuids=None, includeAttributes=None, includeLargestResourceMime=None, includeLargestResourceSize=None,):
resultsSpec = NotesMetadataResultSpec(includeTitle=True)
fetch_results = _get_note_store().findNotesMetadata(
filter, 0, 10, resultsSpec)
real_notes = []
for n in fetch_results.notes:
#note = _get_note_store().getNote(n.guid, withContent=True, withResourcesData=False, withResourcesRecognition=False, withResourcesAlternateData=False)
note = _get_note_store().getNote(n.guid, True, False, False, False)
real_notes.append(note)
return real_notes
def get_note_dict_in_notebook(self, notebook_name="", stack_name=""):
notebooks = self.note_store.listNotebooks()
print "Found ", len(notebooks), " notebooks:"
notebook_guids = []
for notebook in notebooks:
if (notebook.stack and stack_name and notebook.stack.endswith(stack_name)) or \
(notebook.name and notebook_name and notebook.name.endswith(notebook_name)):
print notebook.name
# notebook = self.note_store.getNotebook(notebook.guid)
notebook_guids.append(notebook.guid)
return self.get_note_dict_in_filterlist(
[NoteFilter(notebookGuid=guid) for guid in notebook_guids])
def find_recent_notes(recent_days=1):
logger.info("function starting - find_recent_notes: %d", recent_days)
filter = NoteFilter()
filter.ascending = True
filter.order = NoteSortOrder.UPDATED
filter.words = "updated:day-" + str(recent_days)
spec = NotesMetadataResultSpec()
spec.includeTitle = True
spec.includeUpdated = True
offset = 0
pagesize = 50
while True:
logger.info("fetching, offset: %d", offset)
result = get_store().findNotesMetadata(token, filter, offset, pagesize, spec)
logger.info("fetched %d out of %d notes", len(result.notes), result.totalNotes)
for metadata in result.notes:
yield note_by_guid(metadata.guid)
offset += pagesize
if result.totalNotes <= offset:
break
def find_notes(self,
count=1,
keywords=None,
notebook_guid=None,
tag_guids=None,
order=ttypes.NoteSortOrder.CREATED):
spec = NotesMetadataResultSpec(includeTitle=True,
includeUpdated=True,
includeTagGuids=True)
note_filter = NoteFilter(words=keywords,
order=order,
notebookGuid=notebook_guid,
tagGuids=tag_guids)
return self.noteStore.findNotesMetadata(self.client.token, note_filter,
0, count, spec)
def et_list_notes(**kwa):
"""
Can we get a list of notes?
"""
if kwa['d']:
pdb.set_trace()
client = get_authorized_client('full')
note_store = client.get_note_store()
flt = NoteFilter(words="")
spec = NotesMetadataResultSpec(includeTitle=True)
md_list = note_store.findNotesMetadata(flt, 0, 250, spec)
for note in md_list.notes:
print(note.title)
print(" {}".format(note.guid))
def _iter_all_notes(self):
"""Iterate all notes"""
offset = 0
while True:
note_list = self.note_store.findNotes(
self.auth_token,
NoteFilter(
order=NoteSortOrder.UPDATED,
ascending=False,
), offset, EDAM_USER_NOTES_MAX)
for note in note_list.notes:
yield note
offset = note_list.startIndex + len(note_list.notes)
if note_list.totalNotes - offset <= 0:
break
def main():
"""Generates tag cloud using the Evernote API and word_cloud library"""
setup_logging()
print_version()
args = command_line_args()
verbose, sandbox, image_file, image_width, image_height, mask_file, font_file, max_tags, horizontal_tags, tag_scaling, tag_color_scheme, evernote_auth_token = parse_args(
args)
tags, note_collection_counts = retrieve_tags_and_note_collection_counts(
evernote_auth_token, sandbox, NoteFilter())
tag_counts = determine_tag_counts(tags, note_collection_counts)
tag_cloud = generate_tag_cloud(image_width, image_height, max_tags,
horizontal_tags, tag_scaling,
tag_color_scheme, mask_file, font_file,
tag_counts, verbose)
save_tag_cloud(tag_cloud, image_file)
def get_ev_notes():
dev_token = app.config['EN_DEV_TOKEN']
notestore_url = app.config['EN_NOTESTORE_URL']
nb_guid = app.config['EN_NB_GUID']
client = EvernoteClient(token=dev_token)
note_store = client.get_note_store()
filt = NoteFilter()
filt.notebookGuid = nb_guid
spec = NotesMetadataResultSpec()
spec.includeTitle = True
notemetalist = note_store.findNotesMetadata(dev_token, filt, 0, 100, spec)
notes = []
for note_data in notemetalist.notes:
note = note_store.getNote(dev_token, note_data.guid, True, True, True, True)
title = note.title
author = note.attributes.author
date = note.updated
url = note.attributes.sourceURL
cont = note.content
note_tags = []
tag_guids = note.tagGuids
if tag_guids is not None:
for tag_guid in tag_guids:
tag = note_store.getTag(dev_token, tag_guid)
note_tags.append({'guid': tag_guid, 'name': tag.name})
notes.append({'guid': note_data.guid, 'title': title, 'date_modified': date, 'author': author, 'content': cont, 'tags': note_tags})
#print notes
return dumps(notes)
def _get_evernote_data():
"""Helper method that gets data.
Update to give more control to which notes you get.
"""
# Set up the NoteStore client
client = EvernoteClient(token=DEV_TOKEN)
note_store = client.get_note_store()
note_filter = NoteFilter(order=NoteSortOrder.UPDATED)
result_spec = NotesMetadataResultSpec(includeTitle=True,
includeCreated=True)
# Make API call.
return note_store.findNotesMetadata(DEV_TOKEN, note_filter, 0, 100,
result_spec)
def getEvernoteResources(config, notebook_guid):
resources = []
client = EvernoteClient(token=config["en_devtoken"],
sandbox=config["en_sandbox"] == "True")
noteStore = client.get_note_store()
# get notes from a specific notebook
noteFilter = NoteFilter(notebookGuid=notebook_guid)
result_spec = NotesMetadataResultSpec(includeTitle=True)
filteredNotes = noteStore.findNotesMetadata(noteFilter, 0, 10, result_spec)
notebooks = noteStore.listNotebooks()
for n in filteredNotes.notes:
print n.title, n.guid
fullnote = noteStore.getNote(n.guid, True, True, False, True)
for r in fullnote.resources:
print r.guid
resources += [(r.guid, r.data.body)]
return resources
def get_note_filter(self,start_time,notebook_name,end_time=None):
for notebook in self.get_note_store().listNotebooks():
if notebook.name == notebook_name:
event_notebook_guid = notebook.guid
break
if event_notebook_guid is None:
raise EvernoteConnectorException("Unable to find a notebook with the name '" + notebook_name + "'")
note_filter = NoteFilter()
note_filter.order = NoteSortOrder.CREATED
note_filter.ascending = True
note_filter.notebookGuid = event_notebook_guid
if end_time is None:
note_filter.words = "created:" + start_time + "Z"
else:
note_filter.words = "created:" + start_time + "Z -" + end_time
return note_filter
from evernote.api.client import EvernoteClient from evernote.edam.notestore.ttypes import NoteFilter, NotesMetadataResultSpec devToken = "S=s1:U=8fc8e:E=150baa2e888:C=14962f1b8a8:P=1cd:A=en-devtoken:V=2:H=00145dc7735d3b5e6f2a70b504aba079" client = EvernoteClient(token = devToken) noteStore = client.get_note_store() filter = NoteFilter() filter.ascending = False spec = NotesMetadataResultSpec() spec.includeTitle = True spec.includeCreated = True spec.includeUpdated = True spec.includeTagGuids = True spec.includeAttributes = True noteList = noteStore.findNotesMetadata(devToken, filter, 0, 100, spec) for n in noteList.notes: print(n.guid) print(n.title) print(n.tagGuids)
def hello():
global latestNote
global updated
global created
auth_token = "S=s1:U=6eb51:E=146ce55b0ee:C=13f76a484f1:P=1cd:A=en-devtoken:V=2:H=5d05df82a62652c0ed8f2e544df37758"
if auth_token == "":
print "Please fill in your developer token"
print "To get a developer token, visit " \
"https://sandbox.evernote.com/api/DeveloperToken.action"
exit(1)
client = EvernoteClient(token=auth_token, sandbox=True)
user_store = client.get_user_store()
version_ok = user_store.checkVersion(
"Evernote EDAMTest (Python)",
UserStoreConstants.EDAM_VERSION_MAJOR,
UserStoreConstants.EDAM_VERSION_MINOR
)
#print "Is my Evernote API version up to date? ", str(version_ok)
#print ""
if not version_ok:
exit(1)
note_store = client.get_note_store()
# List all of the notebooks in the user's account
notebooks = note_store.listNotebooks()
nb = None
#print "Found ", len(notebooks), " notebooks:"
for notebook in notebooks:
#print " * ", notebook.name
if notebook.name == "Note":
nb = notebook;
break
if not nb:
print "Note book is not found in your account"
exit(1)
filter = NoteFilter()
filter.notebookGuid = nb.guid
filter.order = Types.NoteSortOrder.UPDATED
spec = NotesMetadataResultSpec()
spec.includeTitle = True
noteML = note_store.findNotesMetadata(auth_token, filter, 0, 1, spec)
content = ""
content_org = ""
content_new = ""
for note in noteML.notes:
noteID = note.guid
if note.created == created and note.updated == updated:
content = latestNote
else:
content = note_store.getNoteContent(auth_token, noteID);
latestNote = content
created = note.created
updated = note.updated
m = re.search(r'<en-note><div>(?P<content>.+)</div></en-note>', content)
if m:
content_org = "%s\n" % m.group('content')
content = re.sub('<[^>]*>', '', content_org)
line = '''<tspan x="%d" y="%d">%s</tspan>'''
n = 57
m = 0
index = n
y_aix = 450
length = len(content)
while index <= length:
while ord(content[index-1]) < 128 and content[index-1] != ' ' and index != length:
index = index - 1
index = ( m+n if index == m else index)
content_new += line%(300, y_aix, content[m:index])
if index == length:
break
y_aix = y_aix + 30
m = index
index = index + n
if index > length:
index = length
content_new = content_new.decode('utf-8')
content_org = content_org.decode('utf-8')
#output = weather.getAndDraw()
output = getWeather.w2svg("forecast")
#output = codecs.open('weather-script-output.svg', 'r', encoding='utf-8').read()
output = output.replace('NOTE_TEXT', content_new)
output = output.replace('NOTE_ORG', content_org)
## Write output
#codecs.open('weather.svg', 'w', encoding='utf-8').write(output)
return output
def getNotes(self):
noteFilter = NoteFilter()
noteFilter.notebookGuid = self.__dict__["notebook"].guid
noteList = self.noteStore.findNotes(self.__dict__["authToken"], noteFilter, 0, int(MAX_NOTES))
return [Note(note, self.__dict__["noteStore"], self.__dict__["authToken"]) for note in noteList.notes]
from evernote.api.client import EvernoteClient
from evernote.edam.notestore.ttypes import NoteFilter, NotesMetadataResultSpec
from evernote.edam.type.ttypes import NoteSortOrder
dev_token = "S=s1:U=8fb0e:E=150ba27eb99:C=1496276bc48:P=1cd:A=en-devtoken:V=2:H=cb6610893ef12aa4b914d15d19befa09"
client = EvernoteClient(token=dev_token, sandbox=True)
NoteStore = client.get_note_store()
filterNote = NoteFilter(order=NoteSortOrder.UPDATED)
filterNote.notebookGuid = 'cdbc8617-c551-4148-b659-7ccb5d47859e'
searchResults = NoteStore.findNotes(filterNote, 0, 10)
def getImage(count, rerun):
for note in searchResults.notes:
if note.resources != None:
for r in note.resources:
guid = r.guid
print guid
try:
resource = NoteStore.getResource(guid, True, False, True, False)
# get the file content so you can save it
file_content = resource.data.body
#print file_content
file_name = resource.attributes.fileName
# save the file into the output folder
file_save = open('../Calvin/output/' + file_name, "wb")
file_save.write(file_content)
import evernote.edam.userstore.constants as UserStoreConstants from evernote.edam.notestore.ttypes import NoteFilter import evernote.edam.type.ttypes as Types from evernote.api.client import EvernoteClient # Sandbox: https://sandbox.evernote.com/api/DeveloperToken.action # Production: https://www.evernote.com/api/DeveloperToken.action auth_token = "S=s1:U=8f65c:E=14fa7113473:C=1484f600570:P=1cd:A=en-devtoken:V=2:H=484744fd0ffa906797416ae02ce5cd9c" client = EvernoteClient(token=auth_token, sandbox=True) note_store = client.get_note_store() # GET CONTENT noteFilter = NoteFilter() noteFilter.order = 1 #http://dev.evernote.com/documentation/reference/Types.html#Enum_NoteSortOrder noteFilter.ascending = False noteList = note_store.findNotes(auth_token, noteFilter, 0, 50 ) guid = "3d958539-6cb7-4bd3-94a7-0240069ad9fb" content = note_store.getNoteContent( auth_token, guid ) print content sys.exit() # Listar todos notebooks:
