def storeMetadata(note_store):
'''
Store tagged metadata in data file
'''
filter = NSTypes.NoteFilter()
resultSpec = NSTypes.NotesMetadataResultSpec()
for notebook in note_data['notebooks']:
filter.notebookGuid = notebook['guid']
filter.tagGuids = makeValueList(note_data, 'tags', 'guid')
resultSpec.includeTitle = True
resultSpec.includeUpdateSequenceNum = True
resultSpec.includeNotebookGuid = True
try:
metalist = note_store.findNotesMetadata(filter, 0, 250, resultSpec)
meta_notes = metalist.notes
if not meta_notes:
raise Exception('Found no tagged note')
except EDAMNotFoundException as e:
raise Exception('Found wrong {}'.format(e.identifier))
except Exception as e:
raise Exception(e)
#
guids = makeValueList(note_data, 'notes', 'guid')
meta_notes_create = []
# Update
for mn in meta_notes:
if mn.guid in guids:
updateNoteData(mn)
else:
meta_notes_create.append(mn)
# Create
for mn in meta_notes_create:
createNoteData(mn)
def get_filtered_notes(filter):
results = list()
nFilter = NoteStoreTypes.NoteFilter()
# reminderOrder, reminderTime, reminderDoneTime
nFilter.words = filter
rSpec = NoteStoreTypes.NotesMetadataResultSpec()
rSpec.includeTitle = True
rSpec.includeAttributes = True
rSpec.includeTagGuids = True
notesMetadataList = noteStore.findNotesMetadata(nFilter, 0, 50, rSpec)
for note in notesMetadataList.notes:
tags = list()
try:
for tagguid in note.tagGuids:
tag = noteStore.getTag(tagguid)
tags.append(tag.name)
except:
pass
results.append({
'title': note.title,
'guid': note.guid,
'donetime': note.attributes.reminderDoneTime,
'duetime': note.attributes.reminderTime,
'reminder': note.attributes.reminderOrder,
'tags': tags
})
return results
def find_notes_metadata(self, notebook=None):
note_filter = NoteStoreTypes.NoteFilter(order=CommonTypes.NoteSortOrder.TITLE, ascending=False)
if notebook is not None:
note_filter.notebookGuid = notebook.guid
spec = NoteStoreTypes.NotesMetadataResultSpec(includeTitle=True)
return self.note_store.findNotesMetadata(self.token, note_filter, 0, LimitConstants.EDAM_USER_NOTES_MAX, spec)
def listnotes():
client = EvernoteClient(token=settings.TOKEN)
notestore = client.get_note_store()
note_filter = ttypes.NoteFilter()
# TODO: read notebookGuid from options
note_filter.notebookGuid = '6ccaa7d7-cbdb-4190-8c28-121e603f0b8c'
note_result_spc = ttypes.NotesMetadataResultSpec(
True,
True,
True,
True,
True,
)
notecount = notestore.findNoteCounts(note_filter, True)
print '==========='
print notecount.notebookCounts
print notecount.tagCounts
print notecount.trashCount
total_count = sum(notecount.notebookCounts.values(), 0)
print total_count
note_list = notestore.findNotesMetadata(
note_filter,
0,
total_count,
)
def find_note_ids(self, place, category='', conditions=[]):
'''
:return List of guids of matching notes
'''
# Create a search filter for notes with same place, conditions, and category
note_filter = NoteStore.NoteFilter()
if type(place) in [unicode, str] and type(category) in [unicode, str] and type(conditions) == list:
placename = 'placeName:"{}"'.format(place)
title = 'inTitle:{}'.format(category)
tags = ''
if len(conditions) > 0:
tags = ' tag:"{}"'.format(conditions[0])
if len(conditions) > 1:
for condition in conditions[1:]:
tags += ' tag:"{}"'.format(condition)
else:
# No conditions specified
pass
else:
raise TypeError, "place and category must be string, and conditions must be list of strings"
note_filter.words = placename + ' ' + title + tags
resultspec = NoteStore.NotesMetadataResultSpec()
resultspec.includeTitle = True
resultspec.includeContent = True
notes_metadata_list = self.noteStore.findNotesMetadata(self.authToken, note_filter, 0, EDAM_USER_NOTES_MAX,
resultspec)
matching_note_guids = [note.guid for note in notes_metadata_list.notes]
return matching_note_guids
def __init__(self, note_class):
self.model_class = note_class
self.interface = note_class.interface
self.note_store = self.interface.get_note_store()
self.note_filter = NoteStore.NoteFilter()
self.guids = set()
self.spec = NoteStore.NotesMetadataResultSpec()
# These are the spec instance properties you can set:
# includeUpdateSequenceNum
# includeDeleted
# includeContentLength
# includeTitle
# includeNotebookGuid
# includeTagGuids
# includeLargestResourceSize
# includeAttributes
# includeLargestResourceMime
# includeCreated
# includeUpdated
self.spec.includeTitle = True
self.spec.includeCreated = True
self.spec.includeUpdated = True
self.spec.includeNotebookGuid = True
self.spec.includeTagGuids = True
self.bounds = {"limit": 50, "offset": 0}
def _get_note_metadata(self):
notefilter = NotesStore.NoteFilter()
notefilter.notebookGuid = self.notebook.guid
resultspec = NotesStore.NotesMetadataResultSpec()
resultspec.includeTitle = True
resultspec.includeCreated = True
resultspec.includeUpdated = True
notelist = self.noteStore.findNotesMetadata(notefilter, 0, 10,
resultspec)
return notelist.notes
def getNotes(self, words):
note_filter = NoteStore.NoteFilter()
note_filter.words = words
notes_metadata_result_spec = NoteStore.NotesMetadataResultSpec()
notes = self.noteStore.findNotesMetadata(
note_filter, 0, 1, notes_metadata_result_spec
)
return notes
def retrieve_titles(self):
note_filter = NoteStore.NoteFilter()
note_filter.words = 'intitle:*'
resultspec = NoteStore.NotesMetadataResultSpec()
resultspec.includeTitle = "True"
results = self.noteStore.findNotesMetadata(self.authToken, note_filter, 0, EDAM_USER_NOTES_MAX, resultspec)
titles = []
for note in results.notes:
titles.append(note.title)
print note.title
unique_places = list(set(titles))
return unique_places
def GetAllNotesWithFilter(EvernoteObject, filterText):
nFilter = NoteStoreTypes.NoteFilter()
nFilter.words = filterText # "reminderOrder:*"
# filter.notebookGuid = "SomeNotebookGuidHere"
# filter.tagGuids = ["tagGuid1", "tagGuid2"]
rSpec = NoteStoreTypes.NotesMetadataResultSpec()
rSpec.includeTitle = True
rSpec.includeAttributes = True
rSpec.includeNotebookGuid = True
notesMetadataList = EN.notestore.findNotesMetadata(nFilter, 0, 50, rSpec)
return notesMetadataList.notes
def listUpdateStateOfNotes(notebook_guid):
notebook_filter = StoreTypes.NoteFilter(notebookGuid=notebook_guid)
spec = StoreTypes.NotesMetadataResultSpec(
includeContentLength=True, includeUpdated=True,
includeDeleted=True, includeUpdateSequenceNum=True,
includeNotebookGuid=True)
temp_list = note_store.findNotesMetadata(notebook_filter,0,
constants.EDAM_USER_NOTES_MAX, spec)
note_list = temp_list.notes
while len(note_list) < temp_list.totalNotes:
temp_list = note_store.findNotesMetadata(notebook_filter,
len(note_list), constants.EDAM_USER_NOTES_MAX, spec)
note_list.append(temp_list.notes)
return note_list
def retrieve_placenames(self):
if offline.real_mode is False:
return offline.places
else:
note_filter = NoteStore.NoteFilter()
note_filter.words = 'placename:*'
resultspec = NoteStore.NotesMetadataResultSpec()
resultspec.includeAttributes = "True"
results = self.noteStore.findNotesMetadata(self.authToken, note_filter, 0, EDAM_USER_NOTES_MAX, resultspec)
placenames = []
for note in results.notes:
placenames.append(note.attributes.placeName)
unique_places = list(set(placenames))
return unique_places
def remove_items(self, items, note_guid=None):
note_filter = NoteStore.NoteFilter()
resultspec = NoteStore.NotesMetadataResultSpec()
results = self.noteStore.findNotesMetadata(self.authToken, note_filter, 0, EDAM_USER_NOTES_MAX, resultspec)
# find all notes with item, and remove the item
if note_guid:
sleep(0.5)
note = self.noteStore.getNote(self.authToken, note_guid, True, False, False, False)
updated_note = ttypes.Note()
updated_content = note.content
for item in items:
updated_content = re.sub(enml_regex['todo_tag'] + re.escape(item), '', updated_content)
updated_note.content = updated_content
updated_note.title = note.title
updated_note.guid = note.guid
self.update_note(updated_note)
def fetchNotesMetadata(self):
logging.info("Getting metadata from notebook: %s", self.notebook_name)
flt = ns_ttypes.NoteFilter()
flt.notebookGuid = self.ev_notebook.guid
rs = ns_ttypes.NotesMetadataResultSpec()
rs.includeTitle = True
rs.includeTagGuids = True
nml = self.ev_note_store.findNotesMetadata(self.token, flt, 0, 10000,
rs)
for n in nml.notes:
#n is "NoteMetadata" type
self.ev_notes_metadata.append([n.guid, n.title])
if n.tagGuids:
for t in n.tagGuids:
self.ev_tags[t] = None
else:
logging.info("No Tag found for: %s ", n.title)
return
def cmd_notes(args, offset=0, count=10):
"""notes [+notebook] [[:tag1 [:tag2] ...] [--offset=X] [--count=Y] -
list notes in the specified notebook, or the current one if not specified.
"""
tags = []
for arg in args:
if arg.startswith('+'):
set_current_notebook_name(arg[1:])
if arg.startswith(':'):
tags.append(arg[1:])
nb_guid = get_current_notebook().guid
nf = NoteTypes.NoteFilter(notebookGuid=nb_guid)
nb_tags = get_note_store().listTagsByNotebook(nb_guid) or []
if tags:
nf.tagGuids = [t.guid for t in nb_tags if t.name in tags]
resultspec = NoteTypes.NotesMetadataResultSpec()
for field in ['includeTitle', 'includeUpdated', 'includeTagGuids']:
setattr(resultspec, field, True)
notesml = get_note_store().findNotesMetadata(nf, int(offset), int(count),
resultspec)
debug(lambda: "Notes in notebook '%s': " % get_current_notebook_name())
for note in notesml.notes:
notetags = note.tagGuids or []
tagdisplay = ["[%s]" % t.name for t in nb_tags if t.guid in notetags]
updatedisplay = time.strftime("%m/%d",
time.localtime(note.updated / 1000))
print(" %s %s %s %s" %
(note.guid, updatedisplay, tagdisplay, note.title))
remaining = notesml.totalNotes - notesml.startIndex - len(notesml.notes)
if remaining > 0:
print("...and %d more." % remaining)
def createOrUpdateNotebooksWeeks(EvernoteObject,
startdate,
enddate,
stackName,
dateOverdue=None):
weeks = GetFirstDaysOfWeeksBetween(startdate, enddate)
notebooks = EvernoteObject.notestore.listNotebooks()
# search notebooks in stack
nbooksWv = [n for n in notebooks if n.stack == stackName]
# iterate all weeks
for weekday in weeks:
weeknumber = weekday.isocalendar()[1]
weekString = GetWeekString(weekday)
# notebook exists in this week?
existingNotebookInThisWeek = GetNotebookSameWeekIfExists(
weekday, nbooksWv)
if existingNotebookInThisWeek == None:
# create new notebook
notebook = EnTypes.Notebook()
notebook.name = weekString
notebook.stack = stackName
notebook = EvernoteObject.notestore.createNotebook(notebook)
msg = "created new notebook '" + notebook.name + "'"
else:
if dateOverdue <> None and weekday.date() < dateOverdue.date():
# Notebook is obsolete
noteFilter = NoteStoreTypes.NoteFilter(
notebookGuid=existingNotebookInThisWeek.guid)
spec = NoteStoreTypes.NotesMetadataResultSpec()
notelist = EvernoteObject.notestore.findNotesMetadata(
noteFilter, 0, 10, spec)
#if notelist.totalNotes > 0:
# it contains notes
oldName = existingNotebookInThisWeek.name
existingNotebookInThisWeek.name = weekString + ": overdue!"
notebook = EvernoteObject.notestore.updateNotebook(
existingNotebookInThisWeek)
msg = "overdue notebook '{o}' contains {cnt:d} Notes, rename to '{new}'".format(
o=oldName,
cnt=notelist.totalNotes,
new=existingNotebookInThisWeek.name)
# else:
# # it contains no notes: delete notebook
# EvernoteObject.notestore.deleteNotebook(existingNotebookInThisWeek)
else:
# Notebook belongs to current or future week
if weekString == existingNotebookInThisWeek.name:
# new name the same as old, so don't update anything
msg = "existing notebook '" + existingNotebookInThisWeek.name + "' name is correct, no update required"
else:
# Update existing notebook
oldName = existingNotebookInThisWeek.name
existingNotebookInThisWeek.name = weekString
notebook = EvernoteObject.notestore.updateNotebook(
existingNotebookInThisWeek)
msg = "updated existing notebook '" + oldName + "' to '" + existingNotebookInThisWeek.name + "'"
print " {msg}".format(msg=msg)
# Create UserStore instance
user_store = client.get_user_store()
# Create NoteStore instance
note_store = client.get_note_store()
# Retrieve User object
user = user_store.getUser()
print "Username: %s" % user.username
print "Name: %s" % user.name
raw_input("Type return to continue...")
# Search notes for To-Do / Followup
nFilter = NoteStoreTypes.NoteFilter()
nFilter.words = "To-Do / Followup"
resultSpec = NoteStoreTypes.NotesMetadataResultSpec()
resultSpec.includeTitle = True
searchResults = note_store.findNotesMetadata(nFilter, 0, 10, resultSpec)
if len(searchResults.notes):
for note in searchResults.notes:
print note.guid
print note.title
my_note = note_store.getNote(note.guid, True, True, False, False)
print my_note.content
print ''
xml = ET.fromstring(my_note.content)
print parseString(my_note.content).toprettyxml()
for child in xml.iter('en-todo'):
print child.tag, child.attrib, child.tail
#note.content = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">'
#note.content += '<en-note>Hello, world!</en-note>'
#note = noteStore.createNote(note)
#noteStore = client.get_note_store()
#notebook = Types.Notebook()
#notebook.name = "My Notebook"
#notebook = noteStore.createNotebook(notebook)
#print notebook.guid
client = EvernoteClient(token=dev_token)
note_store = client.get_note_store()
note_filter = NoteStore.NoteFilter()
note_filter.words = 'intitle:"test"'
notes_metadata_result_spec = NoteStore.NotesMetadataResultSpec()
notes_metadata_list = note_store.findNotesMetadata(note_filter, 0, 1,
notes_metadata_result_spec)
note_guid = notes_metadata_list.notes[0].guid
note = note_store.getNote(note_guid, True, False, False, False)
print note
auth_token = 'your-token'
client = EvernoteClient(token=dev_token)
note_store = client.get_note_store()
updated_filter = NoteFilter(order=NoteSortOrder.UPDATED)
offset = 0
max_notes = 10
def store_evernote(recipes,
args,
site_config,
evernote_cred,
is_note_exist_check=True):
client = EvernoteClient(token=evernote_cred["developer_token"],
sandbox=evernote_cred["is_sandbox"])
note_store = None
try:
note_store = client.get_note_store()
except:
logger.error(sys.exc_info()[0])
if note_store is None:
logger.error("note store in Evernote is None")
return
notebook_name = evernote_cred["notebook_name"]
notebooks = note_store.listNotebooks()
target_notebook = None
for notebook in notebooks:
if notebook_name == notebook.name:
target_notebook = notebook
break
if target_notebook is None:
logger.info("create notebook: {}".format(notebook_name))
target_notebook = Types.Notebook()
target_notebook.name = notebook_name
target_notebook = note_store.createNotebook(target_notebook)
# for processed_list_filename, recipe in recipes(args, site_config):
for recipe in recipes():
trans = recipe_crawler.translators.EvernoteTranslator(
recipe, site_config)
note_title = trans.title
is_note_exist = False
if is_note_exist_check:
note_filter = NSTypes.NoteFilter()
note_filter.notebookGuid = target_notebook.guid
note_filter.words = note_title
resultSpec = NSTypes.NotesMetadataResultSpec()
resultSpec.includeTitle = True
metalist = note_store.findNotesMetadata(note_filter, 0, 10,
resultSpec)
for meta_ in metalist.notes:
if note_title == meta_.title:
logger.debug("skip: {} exists.".format(note_title))
is_note_exist = True
break
if not is_note_exist:
logger.info("create note: {}".format(note_title))
resources, body = trans.body_resources
attributes = trans.attributes
note = Types.Note(title=note_title,
content=body,
resources=resources.values(),
attributes=attributes,
notebookGuid=target_notebook.guid)
note.tagNames = trans.tag_names
note_store.createNote(note)
time.sleep(1)
yield recipe
def proc_insert(args):
messages = dict() # key: date, value: list() Message
store_filename = args.work_dir / args.store_file
if store_filename.exists():
with store_filename.open("r") as fp:
messages = yaml.load(fp, Loader=yaml.Loader)
today = datetime.date.today()
if not today in messages:
messages[today] = list()
messages[today].append(Message(" ".join(args.message)))
with store_filename.open("w") as fp:
yaml.dump(messages,
stream=fp,
allow_unicode=True,
default_flow_style=False)
def get_evernote_credential(credential_json_filename):
import json
if not credential_json_filename.exists():
logger.debug("credential file not found: {}".format(
credential_json_filename))
return None
j = None
with credential_json_filename.open("r") as fp:
j = json.load(fp)
if not "evernote" in j:
logger.debug(
"\"evernote\" not found in credential file: {}".format(
credential_json_filename))
return None
cred = j["evernote"]
if "enable" in cred and cred["enable"] == False:
logger.debug(
"\"evernote.enable\" is disable in credential file: {}".format(
credential_json_filename))
return None
if all(key in cred
for key in ("sandbox", "developer_token", "notebook_name")):
return {
"is_sandbox": cred["sandbox"],
"developer_token": cred["developer_token"],
"notebook_name": cred["notebook_name"],
}
else:
logger.debug(
'"sandbox" or "developer_token" or "notebook_name" are not exists in "evernote" section in credential file: {}'
.format(credential_json_filename))
evernote_cred = get_evernote_credential(args.credential_json_filename)
if evernote_cred is None:
logger.info("evernote storage is disabled.")
else:
logger.info("evernote storage is enabled.")
from evernote.api.client import EvernoteClient
import evernote.edam.type.ttypes as Types
import evernote.edam.notestore.ttypes as NSTypes
client = EvernoteClient(token=evernote_cred["developer_token"],
sandbox=evernote_cred["is_sandbox"])
note_store = client.get_note_store()
notebook_name = evernote_cred["notebook_name"]
notebooks = note_store.listNotebooks()
target_notebook = None
for notebook in notebooks:
if notebook_name == notebook.name:
target_notebook = notebook
break
if target_notebook is None:
logger.info("create notebook: {}".format(notebook_name))
target_notebook = Types.Notebook()
target_notebook.name = notebook_name
target_notebook = note_store.createNotebook(target_notebook)
target_note = None
note_title = "memo {:%Y-%m}".format(today)
filter = NSTypes.NoteFilter()
filter.notebookGuid = target_notebook.guid
resultSpec = NSTypes.NotesMetadataResultSpec()
resultSpec.includeTitle = True
metalist = note_store.findNotesMetadata(filter, 0, 10, resultSpec)
for meta_ in metalist.notes:
if note_title == meta_.title:
target_note = note_store.getNote(meta_.guid, True, False,
False, False)
break
if target_note is None:
logger.info("create note: {}".format(note_title))
note = Types.Note()
note.title = note_title
note.content = convert_to_evernote_format(messages)
note.notebookGuid = target_notebook.guid
note_store.createNote(note)
else:
logger.info("update note: {}".format(note_title))
target_note.content = convert_to_evernote_format(messages)
note_store.updateNote(target_note)