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 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 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 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_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 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 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 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 __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 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 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 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 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 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 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 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 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 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 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 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 _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 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_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 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 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
