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 pull(args):
dest_dir = get_abs_dir(args.directory)
skip_cover = args.yes
finished = 0
for f in args.files:
try:
flag = os.path.basename(f)
file = load_file(flag)
if not file:
box = get_box(args.box)
file_filter = NoteTypes.NoteFilter()
if box:
file_filter.notebookGuid = box.guid
file_filter.title = flag
files = get_box_store().findNotes(dev_token, file_filter, 0,
100).notes
file = load_file(files[-1].guid)
if not file:
raise
ouput_file = os.path.join(dest_dir, file['title'])
if os.path.exists(ouput_file):
if not skip_cover:
if not get_yn_input('文件 %s 已存在，是否覆盖' % ouput_file):
continue
with open(ouput_file, 'w') as fp:
fp.write(file['content'])
finished += 1
sys.stdout.write('已拉取：%s个文件\r' % finished)
sys.stdout.flush()
except Exception, e:
print('文件：%s拉取失败，跳过..' % f)
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 getNoteGuidByTagGuid(self, title, tagguid):
f = Ttypes.NoteFilter()
f.tagGuids = [tagguid]
notes = self.note_store.findNotes(self.auth_token, f, 0, 999).notes
for note in notes:
if note.title == title:
return note.guid
def find_note_counts(self, word):
note_filter = NoteStoreTypes.NoteFilter()
note_filter.words = word
note_filter.ascending = False
ret = self.note_store.findNoteCounts(self.token, note_filter, False)
return ret
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 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 in_notebooks(title, notebook_id):
filter = NoteTypes.NoteFilter()
filter.notebookGuid = notebook_id
filter.name = "intitle:%s" % title
results = get_note_store().findNotes(dev_token, filter, 0, 100).notes
for note in results:
if note.title == title:
return note.guid
return None
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 list_notes(notebook_guid, user_store, note_store):
note_filter = NoteTypes.NoteFilter()
note_filter.notebookGuid = notebook_guid
notes = note_store.findNotes(settings.EVERNOTE_DEVELOPER_TOKEN,
note_filter, 0, 100).notes
notes_lst = []
for note in notes:
this_note = {'NoteTitle': note.title, 'NoteId': note.guid}
notes_lst.append(this_note)
return notes_lst
def list_box(box):
file_filter = NoteTypes.NoteFilter()
file_filter.notebookGuid = box.guid
files = get_box_store().findNotes(dev_token, file_filter, 0, 100).notes
if not files:
print '仓库没有任何文本'
else:
print('| 文本id | 文本名称 | 创建时间')
for f in reversed(files):
print "%s %s %s" % (f.guid, f.title, datetime_format(
f.created))
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 change_tag_evernote(args, evernote_cred):
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
note_filter = NSTypes.NoteFilter()
note_filter.notebookGuid = target_notebook.guid
notes_per_page = 50
note_list = note_store.findNotes(note_filter, 0, 1)
note_num = note_list.totalNotes
max_page_num = math.ceil(note_num / notes_per_page)
note_num_digits = len(str(note_num))
message_current_max = "({{:0{digits}d}}/{{:0{digits}d}})".format(
digits=note_num_digits)
for page_num in range(0, max_page_num):
note_list = note_store.findNotes(note_filter,
notes_per_page * page_num,
notes_per_page * (page_num + 1))
for i, note in enumerate(note_list.notes):
logger.info((message_current_max + ": {}").format(
notes_per_page * page_num + i + 1, note_num, note.title))
current_tag_names = note_store.getNoteTagNames(note.guid)
new_tag_names = set()
for current_tag_name in current_tag_names:
try:
program_date = dateutil.parser.parse(current_tag_name)
new_tag_names.add("{:%Y}".format(program_date))
new_tag_names.add("{:%Y.%m}".format(program_date))
except:
new_tag_names.add(current_tag_name)
logger.info("change tags: {}->{}".format(current_tag_names,
new_tag_names))
note.tagGuids.clear()
note.content = None
note.resources = None
note.tagNames = new_tag_names
note_store.updateNote(note)
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 log(args):
file = args.file
abs_path = os.path.abspath(os.path.normpath(file))
if not os.path.exists(abs_path):
print('文件不存在!')
return
file_name = os.path.basename(abs_path)
file_filter = NoteTypes.NoteFilter()
file_filter.title = file_name
files = get_box_store().findNotes(dev_token, file_filter, 0, 100).notes
if not files:
print('仓库中不存在该文件的记录')
return
print('| 文本id | 文本名称 | 仓库\t | 创建时间')
for f in files:
print '%s %s %s %s' % (f.guid, f.title, get_box_by_id(
f.notebookGuid).name, datetime_format(f.created))
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 list_notes_in_notebooks(notebook_id):
filter = NoteTypes.NoteFilter()
filter.notebookGuid = notebook_id
notes = get_note_store().findNotes(dev_token, filter, 0, 100).notes
return notes
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)
def list_notes(client, notebook):
filter = NoteStoreTypes.NoteFilter()
filter.notebookGuid = notebook.guid
noteStore = client.get_note_store()
noteList = noteStore.findNotes(filter, 0, 1000)
return noteList.notes
def sync_fotopedia_id(item_id):
#get html story page
raw_story = requests.get("http://www.fotopedia.com/reporter/stories/" +
item_id)
#pass html story to beautiful soup for html processing
bs_story = bs(raw_story.content)
#grab all titles and captions
editable_spans = bs_story.findAll("span", {'class': "editable-value"})
titles_and_captions = []
for text in editable_spans:
titles_and_captions.append(text.text)
#grab all pic urls from page
re_pattern = "\'background: url\(\"(.*)\"\)"
pic_html = bs_story.findAll("div", {"class": "full-image"})
pic_urls = []
for pic in pic_html:
pic_urls.append(re.findall(re_pattern, pic.renderContents())[0])
#prep evernote
user_store = get_userstore()
note_store = get_notestore()
notebooks = note_store.listNotebooks(session['identifier'])
#check if Fotopedia notebook exists
for notebook in notebooks:
if notebook.name == "Fotopedia":
fotopediaNotebookGuid = notebook.guid
break
#if not create it
try:
fotopediaNotebookGuid
except NameError:
notebook = Types.Notebook()
notebook.name = "Fotopedia"
notebook = note_store.createNotebook(session['identifier'], notebook)
fotopediaNotebookGuid = notebook.guid
#add all pictures as notes with title of story: title of pic with captions as body text
#iterate through all pics and titles
for iter in range(len(pic_urls)):
if titles_and_captions[0] and titles_and_captions[2 * iter]:
note_title = titles_and_captions[0] + " - " + titles_and_captions[
2 * iter]
else:
note_title = titles_and_captions[2 * iter]
note_description = titles_and_captions[2 * iter - 1]
pic_url = pic_urls[iter]
#check to see if note exists already
notebook_filter = NoteStoreTypes.NoteFilter()
notebook_filter.guid = fotopediaNotebookGuid
result_spec = NotesMetadataResultSpec(includeTitle=True)
noteList = note_store.findNotesMetadata(session['identifier'],
notebook_filter, 0, 40000,
result_spec)
for note in noteList.notes:
if note.title == note_title:
continue
#get image
if pic_url == '':
continue
image = requests.get(pic_url, stream=True).content
md5 = hashlib.md5()
md5.update(image)
pic_hash = md5.digest()
data = Types.Data()
data.size = len(image)
data.bodyHash = pic_hash
data.body = image
resource = Types.Resource()
resource.mime = 'image/jpeg'
resource.data = data
hash_hex = binascii.hexlify(pic_hash)
note = Types.Note()
note.notebookGuid = fotopediaNotebookGuid #create note for our Giphy notebook
note.title = note_title
note.content = '<?xml version="1.0" encoding="UTF-8"?>'
note.content += '<!DOCTYPE en-note SYSTEM ' \
'"http://xml.evernote.com/pub/enml2.dtd">'
note.content += '<en-note>' + note_description + '<br/><br/>'
note.content += '<en-media type="image/png" hash="' + hash_hex + '"/>'
note.content += '</en-note>'
note.resources = [
resource
] # Now, add the new Resource to the note's list of resources
note = note_store.createNote(session['identifier'],
note) # create the note
return True
noteStoreHttpClient = THttpClient.THttpClient(noteStoreUri)
noteStoreProtocol = TBinaryProtocol.TBinaryProtocol(noteStoreHttpClient)
noteStore = NoteStore.Client(noteStoreProtocol)
notebooks = noteStore.listNotebooks(authToken)
print "Found ", len(notebooks), " notebooks:"
ofile = codecs.open('ttest.html', 'w', 'utf-8')
for notebook in notebooks:
print " * ", notebook.name
if notebook.defaultNotebook:
defaultNotebook = notebook
# else :
# continue
filter = NoteStoreTypes.NoteFilter()
filter.notebookGuid = notebook.guid
filter.order = 1
filter.words = "todo:*"
filter.ascending = False
filter.timeZone = "Asia/Shanghai"
noteList = noteStore.findNotes(authToken, filter, 0, 100)
print "total notes number :" + str(noteList.totalNotes)
print "startIndex" + str(noteList.startIndex)
print len(noteList.notes)
for note in noteList.notes:
#print note.guid
#print note.title
print chardet.detect(note.title)
ofile.write(note.title + '\n')
noteContent = noteStore.getNoteContent(authToken, note.guid)
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)
