class Library(object):
def __init__(self, auth_token):
"""
Initialize access to the Evernote library.
Arguments:
auth_token (string) Evernote authentication token
Implements the following Evernote client components:
client (EvernoteClient)
noteStore (NoteStore)
userStore (UserStore)
notebooks (list of Notebook)
tags (list of Tag)
"""
self.auth_token = auth_token
self.client = EvernoteClient(token = self.auth_token, sandbox = False)
self.noteStore = self.client.get_note_store()
self.userStore = self.client.get_user_store()
self.notebooks = {}
for notebook in self.noteStore.listNotebooks(self.auth_token):
self.notebooks[notebook.name] = notebook.guid
self.tags = {}
for tag in self.noteStore.listTags(self.auth_token):
self.tags[tag.name] = tag.guid
def callback(request):
client = get_evernote_client()
access_token = ''
if 'oauth_verifier' in request.GET:
oauth_verifier = request.GET.get("oauth_verifier")
access_token = client.get_access_token(
request.COOKIES['oauth_token'],
request.COOKIES['oauth_token_secret'],
oauth_verifier
)
client = EvernoteClient(token=access_token)
user_store = client.get_user_store()
user = user_store.getUser()
username = user.username
shard_id = user.shardId
privilege = user.privilege
# request.session['shard_id'] = shard_id
u = User(
user_id=user.id,
access_token=access_token)
u.save()
# Redirect the user to the Evernote authorization URL
try:
callbackUrl = request.COOKIES['_redirect_url']
except Exception as e :
callbackUrl = 'http://%s/' % (request.get_host())
response = redirect(callbackUrl)
if len(access_token) > 0 :
response.set_cookie('access_token', access_token)
response.delete_cookie('_redirect_url')
return response
def lambda_handler(event, context):
#setting environment variables
user = os.environ['GKEEP_USERNAME']
pw = os.environ['GKEEP_APP_PASSWORD']
noteId = os.environ['GKEEP_NOTE_ID']
authToken = os.environ['EVERNOTE_DEV_TOKEN']
noteGuid = os.environ['EVERNOTE_NOTE_ID']
#keep login
keep = gkeepapi.Keep()
keep.login(user, pw)
#getting keep note contents and converting to html
syncnote = keep.get(noteId)
syncnotebody = syncnote.text
enotepayload = textile.textile(syncnotebody)
#evernote login
client = EvernoteClient(token=authToken)
userStore = client.get_user_store()
user = userStore.getUser()
#updating the evernote note with the keep note contents
noteStore = client.get_note_store()
note = ttypes.Note()
note.guid = noteGuid
note.title = 'Shopping List' #not sure if I should make this a variable
note.content = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd"><en-note>' + enotepayload + '</en-note>'
noteStore.updateNote(authToken, note)
return 0
def get_template_tags(auth_token): """finds a tag with the name 'template' or 'Template' returns a list of tag GUIDs or None""" #setup the Evernote Client client = EvernoteClient(token=session["access_token"], sandbox=sandbox) user_store = client.get_user_store() note_store = client.get_note_store() #get a list of tags in the user's account tags = note_store.listTags() #Check to see if there are tags named 'template' or 'Template' and put them in a list template_tags = None for tag in tags: tag_name = tag.name if tag_name == 'template': if template_tags: template_tags.append(tag.guid) else: template_tags = [tag.guid] if tag_name == 'Template': if template_tags: template_tags.append(tag.guid) else: template_tags = [tag.guid] return template_tags #return a list of tags GUIDs (or None)
def new_template_note(guid):
"""Copies the note specified by the GUID in the URL
redirects the user to open the note in their client"""
#check to see the user has logged in
if "access_token" in session.keys():
#setup Evernote Client
client = EvernoteClient(token=session["access_token"], sandbox=sandbox)
user_store = client.get_user_store()
note_store = client.get_note_store()
#get the default notebook
default_notebook = note_store.getDefaultNotebook()
#copy the note to the default notebook
note = note_store.copyNote(session['access_token'], guid, default_notebook.guid)
#Remove "template" and "Template" tags
for tag in get_template_tags(session['access_token']):
try:
note.tagGuids.remove(tag)
except ValueError:
pass
note = note_store.updateNote(note)
#construct the evernote Link to the newly copied note
in_app_link = "evernote:///view/%s/%s/%s/%s/" % (user_store.getUser().id, user_store.getUser().shardId, note.guid, note.guid)
#redirect the user to the note (will open up in Evernote client)
return redirect(in_app_link)
else:
#if the user is not logged in redirect them to do so
return redirect(url_for("main"))
def main(notebookName):
#Get your developer token here: https://www.evernote.com/api/DeveloperToken.action and put it here
dev_token = 'yourEvernoteDevKey'
#Put your Shotgun script details here
sg = Shotgun('https://yourSite.shotgunstudio.com','evernote-shotgun','yourScriptKey')
#Put the Shotgun HumanUser ID here for the person you want to appear as the Note's author in Shotgun
sgUserId = 45
sgUser = sg.find_one("HumanUser",[['id', 'is', sgUserId]])
#Establish a connection to Evernote and store note and user data
client = EvernoteClient(token=dev_token, sandbox=False)
userStore = client.get_user_store()
user = userStore.getUser()
noteStore = client.get_note_store()
#Check if the supplied notebook exists, and if it does, send to processNotebook()
print('\nFinding notebook')
notebooks = noteStore.listNotebooks()
notebookNames = [notebook.name for notebook in notebooks]
if notebookName not in notebookNames:
print('\nSorry, there are no notebooks in your account named {0}'.format(notebookName))
else:
for notebook in notebooks:
if notebook.name == notebookName:
print('\nProcessing notebook - BEGIN')
processNotebook(noteStore, notebook, sg, sgUser)
print('\nProcessing notebook - DONE\n')
else:
continue
def index():
client = EvernoteClient(token=dev_token)
userStore = client.get_user_store()
user = userStore.getUser()
print user.username
return render_template('index.mak', name='mako', consumer_key=consumer_key,
consumer_secret=consumer_secret)
def auth_start():
dev_token = "S=s1:U=8f624:E=14fa3a78539:C=1484bf65560:P=1cd:A=en-devtoken:V=2:H=a71244ac77727e1a6a2fcb5286ab435a"
client = EvernoteClient(token=dev_token)
userStore = client.get_user_store()
user = userStore.getUser()
list = [1, 2, 3, 4]
return render_template('test.html', list=list)
def _create_new_note(title, url):
# Real applications authenticate with Evernote using OAuth, but for the
# purpose of exploring the API, you can get a developer token that allows
# you to access your own Evernote account. To get a developer token, visit
# https://sandbox.evernote.com/api/DeveloperToken.action
auth_token = AUTH_TOKEN
# Initial development is performed on our sandbox server. To use the production
# service, change sandbox=False and replace your
# developer token above with a token from
# https://www.evernote.com/api/DeveloperToken.action
client = EvernoteClient(token=auth_token, sandbox=False)
user_store = client.get_user_store()
version_ok = user_store.checkVersion(
"linkToEver",
UserStoreConstants.EDAM_VERSION_MAJOR,
UserStoreConstants.EDAM_VERSION_MINOR
)
if not version_ok:
logger.error("My Evernote API version is not up to date")
exit(1)
note_store = client.get_note_store()
logger.info("Creating a new note in the default notebook(%s)", title)
note = Types.Note()
note.title = title
note_attribute = Types.NoteAttributes(sourceURL=url)
note.attributes = note_attribute
return note_store, note
def login():
try:
cfgfile = str(pathlib.Path.home())+'/.evernote-search.cfg'
config = configparser.ConfigParser()
config.read(cfgfile)
auth_token = config['settings']['EVERNOTE_TOKEN']
except Exception:
print('Failed to load Evernote token. Visit https://sandbox.evernote.com/api/DeveloperToken.action',
'to get your developer token and save it to $HOME/.evernote-search-token.cfg like below:\n',
'[settings]\n', 'EVERNOTE_TOKEN = YOUR_DEV_TOKEN\n')
raise EvernoteTokenLoadError
sandbox = False
china = False
client = EvernoteClient(token=auth_token, sandbox=sandbox, china=china)
user_store = client.get_user_store()
version_ok = user_store.checkVersion(
"Evernote EDAMTest (Python)",
UserStoreConstants.EDAM_VERSION_MAJOR,
UserStoreConstants.EDAM_VERSION_MINOR
)
if not version_ok:
exit(1)
return client
def profile():
"""Fetching a protected resource using an OAuth 1 token.
"""
import hashlib
import binascii
import evernote.edam.userstore.constants as UserStoreConstants
import evernote.edam.type.ttypes as Types
from evernote.api.client import EvernoteClient
auth_token = session['oauth_token']
client = EvernoteClient(token=auth_token,
sandbox=True if EVERNOTE_PRODUCTION == 'False' else False)
user_store = client.get_user_store()
version_ok = user_store.checkVersion(
"Evernote EDAMTest (Python)",
UserStoreConstants.EDAM_VERSION_MAJOR,
UserStoreConstants.EDAM_VERSION_MINOR
)
note_store = client.get_note_store()
# List all of the notebooks in the user's account
notebooks = note_store.listNotebooks()
return "<br/>" .join([notebook.name for notebook in notebooks])
def get_api_key():
oauth_verifier = request.args.get("oauth_verifier")
if oauth_verifier: # if this shows up, then we've been authorized.
#
# therefore, now it's time for:
#
# ***STEP 6*** (still in our callback route):
#
# 6a. I think the temporary token you're sent back is the same you sent, but it's not completely clear from the docs, so let's parse it anyway.
#
temporary_token2 = request.args.get("oauth_token")
# but just in case that doesn't really exist and it is the one we had before:
if temporary_token2:
oauth_token = temporary_token2
else:
oauth_token = temporary_request_token
#
# 6b. Send yet ANOTHER request, this time for the proper authorization token
#
access_token = auth_client.get_access_token(oauth_token, oauth_secret,
oauth_verifier)
#
# And we should be authenticated!!! Let's use our new token.
#
real_client = EvernoteClient(token=access_token)
userStore = real_client.get_user_store()
user = userStore.getUser()
return "Hi! You're authenticated, and I can prove it, {}!".format(
user.username)
else: # our request was not authorized. throw an unfriendly error.
abort(401)
def main_evernote(session):
"""
Synchronizes Lectio homework and assignments with Evernote.
"""
token = get_evernote_token()
logger.info("Creating Evernote client.")
client = EvernoteClient(token=token, sandbox=False)
user_store = client.get_user_store()
note_store = client.get_note_store()
logger.info("Getting Lectio assignments.")
assignments = session.get_assignments()
for assignment in assignments:
title = EVERNOTE_ASSIGNMENT_PREFIX + assignment.title
content = ""
if assignment.note:
content += assignment.note
content += "\n\n" + "-" * 30 + "\n\n"
content += "Hold: {}.\n".format(assignment.group)
content += "Elevtid: {} timer.\n".format(assignment.student_hours)
content += "Afleveringsfrist: {}.".format(assignment.deadline)
content = content.replace("\n", "<br/>")
note = make_note(token, note_store, title, content)
class EvernoteSession:
def __init__(self, dev_token):
self.token = dev_token
self.client = EvernoteClient(token=dev_token)
self.userStore = self.client.get_user_store()
self.noteStore = self.client.get_note_store()
def shareNotebook(self, notebookGuid, email=None):
sharedNotebook = Types.SharedNotebook()
sharedNotebook.requireLogin = True
sharedNotebook.notebookGuid = notebookGuid
sharedNotebook.email = email
sharedNotebook.privilege = Types.SharedNotebookPrivilegeLevel.READ_NOTEBOOK_PLUS_ACTIVITY
user = self.userStore.getUser()
shardId = user.shardId
newSharedNotebook = c.noteStore.shareNotebook(sharedNotebook,
"Test message")
# linkedNotebook = Types.LinkedNotebook()
# linkedNotebook.sharedNotebookGlobalId = newSharedNotebook.globalId
# linkedNotebook.shareName = notebookName
# linkedNotebook.username = "******"
# linkedNotebook.shardId = shardId
# newLinkedNotebook = c.noteStore.createLinkedNotebook(dev_token2, linkedNotebook)
# old way: url = "%s/shard/%s/share/%s/" % (EN_URL, shardId, newSharedNotebook.shareKey)
url = ""
return url
def user():
# Checking Access Token
access_token = get_developer_token()
if (access_token == ""):
return safeglobals.MSG_NO_DEVTOKEN
client = EvernoteClient(token=access_token, sandbox=False)
userStore = client.get_user_store()
response = userStore.getUser()
# Setting user data
username = response.username
uid = response.id
email = response.email
privilegeLevel = safeglobals.PRIVILEGE_LEVEL[str(response.privilege)]
premiumStatus = safeglobals.PREMIUM_STATUS[str(
response.accounting.premiumServiceStatus)]
privilege = response.privilege
#return json.dumps(response)
return render_template('user.evernote.html',
username=username,
uid=uid,
email=email,
premiumStatus=premiumStatus,
priv=privilegeLevel)
def __init__(self, key, config, sand_box=False):
self.key = key
self.logger = logging.getLogger('root')
self.cfg = {
"gardening_tag": config['evernote']['GARDENING_TAG'],
"notebook": config['evernote']['NOTEBOOK'],
"plant_tag_id": config['evernote']['PLANT_TAG_ID'],
"location_tag_id": config['evernote']['LOCATION_TAG_ID'],
"state_tag_id": config['evernote']['STATE_TAG_ID'],
"plant_no_id": '+plants', #config['evernote']['PLANT_NO_TAG_ID'],
"sand_box": sand_box,
"force_sync": False
}
#------------------------------------------------------------------------
# Get Account Info
#------------------------------------------------------------------------
client = EvernoteClient(token=self.key['AUTH_TOKEN'], sandbox=sand_box)
self.note_store = client.get_note_store()
self.user_store = client.get_user_store()
#------------------------------------------------------------------------
# Check evernote API
#------------------------------------------------------------------------
version_ok = self.user_store.checkVersion(
"Evernote EDAMTest (Python)",
UserStoreConstants.EDAM_VERSION_MAJOR,
UserStoreConstants.EDAM_VERSION_MINOR)
if not version_ok:
self.logger.warning("Evernote API version is not up to date.")
def makeNoteFromLastCommit(dev_token):
client = EvernoteClient(token=dev_token, sandbox=True)
userStore = client.get_user_store()
user = userStore.getUser()
#print user.username
noteStore = client.get_note_store()
notebooks = noteStore.listNotebooks()
#for n in notebooks:
# print n.name
note = Types.Note()
note.title = sys.argv[1] + " " + sys.argv[2]
note.content = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">'
content = ""
content1 = ""
content2 = ""
parts = sys.argv[1:3]
date = sys.argv[3:10]
msg = sys.argv[10:]
for s in parts:
content += s+" "
for s in date:
content1 += s+" "
for s in msg:
content2 += s+" "
note.content += '<en-note>'+ content + '<br/><br/>' + content1 + '<br/><br/>' + content2 +'</en-note>'
note = noteStore.createNote(note)
class EvernoteController(object):
def __init__(self, token, isSpecialToken=False, sandbox=False, isInternational=False, notebooks=None):
self.token = token
if sandbox:
self.client = EvernoteClient(token=self.token, service_host='sandbox.yinxiang.com')
elif isInternational:
self.client = EvernoteClient(token=self.token, service_host='www.evernote.com')
else:
self.client = EvernoteClient(token=self.token, service_host='app.yinxiang.com')
self.isSpecialToken = isSpecialToken
self.userStore = self.client.get_user_store()
self.noteStore = self.client.get_note_store()
self.storage = Storage(notebooks)
def get_upload_limit(self):
return {
1: 25 * 1024 * 1024,
3: 100 * 1024 * 1024,
5: 200 * 1024 * 1024,
}.get(self.userStore.getUser().privilege, 0)
def create_notebook(self, noteFullPath):
if self.get(noteFullPath): return False
notebook = Types.Notebook()
notebook.name = noteFullPath
try:
notebook = self.noteStore.createNotebook(notebook)
except EDAMUserException, e:
if e.errorCode == 10 and e.parameter == 'Notebook.name':
self.storage.update(self.token, self.noteStore)
return True
else:
raise e
self.storage.create_notebook(notebook)
return True
def init_evernote(self):
self.auth_token = get_local_key("evernote_key.auth_token", "django_local_apps")
# Real applications authenticate with Evernote using OAuth, but for the
# purpose of exploring the API, you can get a developer token that allows
# you to access your own Evernote account. To get a developer token, visit
# https://sandbox.evernote.com/api/DeveloperToken.action
if self.auth_token == "your developer token":
print "Please fill in your developer token"
print "To get a developer token, visit " \
"https://sandbox.evernote.com/api/DeveloperToken.action"
exit(1)
# Initial development is performed on our sandbox server. To use the production
# service, change sandbox=False and replace your
# developer token above with a token from
# https://www.evernote.com/api/DeveloperToken.action
client = EvernoteClient(token=self.auth_token,
sandbox=False
)
# Ref: https://github.com/evernote/evernote-sdk-python/issues/39
client.service_host = 'app.yinxiang.com'
self.user_store = client.get_user_store()
version_ok = self.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)
self.note_store = client.get_note_store()
class UserCoordinator:
def __init__(self, auth_token, is_sandbox):
self.client = EvernoteClient(token=auth_token, sandbox=is_sandbox)
def get_user(self):
user_store = self.client.get_user_store()
return user_store.getUser()
def main():
# Checking if we have Lynx / phantomJS for optional features
#Is Lynx installed?
print "Can we use lynx to extract text?"
lynx_exe = canhaslynx()
if lynx_exe:
print "yes"
else:
print "no"
#Is phantomJS installed?
print "Can we use phantomJS to extract screenshots?"
phantom_exe = canhasphantom()
if phantom_exe:
print "yes"
else:
print "no"
print "connecting to Evernote…"
client = EvernoteClient(token=evernote_token, sandbox=False)
user_store = client.get_user_store()
try:
note_store = client.get_note_store()
except Errors.EDAMSystemException, e:
if e.errorCode == 19: # rate limit reached
print "Rate limit reached"
print "Retry your request in %d seconds" % e.rateLimitDuration
time.sleep(e.rateLimitDuration+1)
note_store = client.get_note_store()
class EvernoteSession:
def __init__(self, dev_token):
self.token = dev_token
self.client = EvernoteClient(token=dev_token)
self.userStore = self.client.get_user_store()
self.noteStore = self.client.get_note_store()
# def listAllNotes(self, notebookGuid=None):
# noteFilter = NoteStore.NoteFilter()
# # http://dev.evernote.com/documentation/reference/NoteStore.html#Struct_NoteFilter
# if notebookGuid:
# noteFilter.notebookGuid = notebookGuid
# searchResults = self.noteStore.findNotes(self.token, noteFilter, 0, 50)
# return searchResults.notes
def shareNotebook(self, notebookGuid, email=None):
sharedNotebook = Types.SharedNotebook()
sharedNotebook.requireLogin = True
sharedNotebook.notebookGuid = notebookGuid
sharedNotebook.email = email
sharedNotebook.privilege = Types.SharedNotebookPrivilegeLevel.READ_NOTEBOOK_PLUS_ACTIVITY
newSharedNotebook = c.noteStore.createSharedNotebook(c.token, sharedNotebook)
user = self.userStore.getUser()
shardId = user.shardId
url = "%s/shard/%s/share/%s/" % (EN_URL, shardId, newSharedNotebook.shareKey)
return url
class EvernoteSession:
def __init__(self, dev_token):
self.token = dev_token
self.client = EvernoteClient(token=dev_token)
self.userStore = self.client.get_user_store()
self.noteStore = self.client.get_note_store()
def internalNoteLink(self, noteGuid):
# Original: evernote:///view/13708770/s129/abe5f3b4-b305-4172-b5c9-985cc2ba5e78//
# Stripped: evernote:///view/0/s129/abe5f3b4-b305-4172-b5c9-985cc2ba5e78/00000000-0000-0000-0000-000000000000/
# Template: evernote:///view/<ownerid>/<shardid>/<noteguid>/<localvalue>/<linkedNotebookValue>
user = self.userStore.getUser()
shardId = user.shardId
userId = user.id
localWTF = "00000000-0000-0000-0000-000000000000"
return "%sview/%d/%s/%s/%s/" % ("evernote:///", userId, shardId, noteGuid, localWTF)
def listAllNotes(self):
noteFilter = NoteStore.NoteFilter()
# http://dev.evernote.com/documentation/reference/NoteStore.html#Struct_NoteFilter
# notebook = self.noteStore.getDefaultNotebook()
# noteFilter.notebookGuid = notebook.guid
searchResults = self.noteStore.findNotes(self.token, noteFilter, 0, 50)
return searchResults.notes
def new_template_note(guid):
"""Copies the note specified by the GUID in the URL
redirects the user to open the note in their client"""
# Check to see the user has logged in
if "access_token" in session.keys():
# Setup Evernote Client
client = EvernoteClient(token=session["access_token"], sandbox=sandbox)
user_store = client.get_user_store()
business_store = client.get_business_note_store()
auth_result = user_store.authenticateToBusiness()
business_shard_id = auth_result.user.shardId
business_user_id = auth_result.user.id
business_token = auth_result.authenticationToken
# Construct the evernote Link to the newly copied note
in_app_link = "evernote:///view/%s/%s/%s/%s/" % (
business_user_id,
business_shard_id,
guid,
guid
)
# Redirect the user to the note (opens in Evernote client)
return redirect(in_app_link)
else:
# If the user is not logged in redirect them to do so
return redirect(url_for("main"))
def auth_start():
dev_token = "S=s1:U=8f624:E=14fa3a78539:C=1484bf65560:P=1cd:A=en-devtoken:V=2:H=a71244ac77727e1a6a2fcb5286ab435a"
client = EvernoteClient(token=dev_token)
userStore = client.get_user_store()
user = userStore.getUser()
list = [1, 2, 3, 4]
return render_template('test.html', list = list)
class myEvernote(object):
def __init__(self, kontoname):
if kontoname == "loipe":
self._connect_to_evernote(evernoteApiKeys.dev_tokenLoipe,
istSandbox=False)
else:
self._connect_to_evernote(evernoteApiKeys.dev_tokenSandbox,
istSandbox=True)
def _connect_to_evernote(self, dev_token, istSandbox=True):
user = None
try:
self.client = EvernoteClient(token=dev_token, sandbox=istSandbox)
self.user_store = self.client.get_user_store()
self.notestore = self.client.get_note_store()
user = self.user_store.getUser()
except EDAMUserException as e:
err = e.errorCode
print("Error attempting to authenticate to Evernote: %s - %s" %
(EDAMErrorCode._VALUES_TO_NAMES[err], e.parameter))
return False
except EDAMSystemException as e:
err = e.errorCode
print("Error attempting to authenticate to Evernote: %s - %s" %
(EDAMErrorCode._VALUES_TO_NAMES[err], e.message))
sys.exit(-1)
if user:
print("Authenticated to evernote as user %s" % user.username)
return True
else:
return False
def get():
# conn = dbConnector()
# c = conn.cursor()
p={}
if 'token' not in request.cookies:
return redirect(url_for('auth_start'))
else:
cToken = request.cookies.get('token')
client = EvernoteClient(token=cToken,sandbox=False)
#Evernoteからユーザー情報を取得する。
if 'user' not in session:
us = client.get_user_store()
user = us.getUser()
session['username'] = user.username
session['uid'] = user.id
#Evernoteからタグを取得する
if 'tags' not in session:
evernoteTag(client)
else:
pass
if 'perms' in session:
p=session['perms']
session['perms']=None
else:
perms=None
return render_template('index.html', perms=p)
class ZKClient(object):
def __init__(self, **kwargs):
self._en_client = EvernoteClient(
consumer_key=kwargs.get('consumer_key'),
consumer_secret=kwargs.get('consumer_secret'),
token=kwargs.get('token'),
sandbox=kwargs.get('sandbox', False))
self._user_store = None
self._note_store = None
self.user = user.ZKUserClient(self)
self.notebooks = notebook.ZKNotebookClient(self)
self.notes = note.ZKNoteClient(self)
self.tags = tag.ZKTagClient(self)
def get_user_store(self):
if not self._user_store:
self._user_store = self._en_client.get_user_store()
return self._user_store
def get_note_store(self):
if not self._note_store:
self._note_store = self._en_client.get_note_store()
return self._note_store
def connect(self, token=''):
if token:
self.token = token
client = EvernoteClient(token=self.token)
self.client = client
self.note_store = client.get_note_store()
self.user_store = client.get_user_store()
class EvernoteController(object):
def __init__(self, token, isSpecialToken = False, sandbox = False, isInternational = False, notebooks = None):
self.token = token
if sandbox:
self.client = EvernoteClient(token=self.token)
elif isInternational:
self.client = EvernoteClient(token=self.token, service_host='www.evernote.com')
else:
self.client = EvernoteClient(token=self.token, service_host='app.yinxiang.com')
self.isSpecialToken = isSpecialToken
self.userStore = self.client.get_user_store()
self.noteStore = self.client.get_note_store()
self.storage = Storage(notebooks)
def get_upload_limit(self):
return {
1: 25 * 1024 * 1024,
3: 100 * 1024 * 1024,
5: 200 * 1024 * 1024,
}.get(self.userStore.getUser().privilege, 0)
def create_notebook(self, noteFullPath):
if self.get(noteFullPath): return False
notebook = Types.Notebook()
notebook.name = noteFullPath
try:
notebook = self.noteStore.createNotebook(notebook)
except EDAMUserException, e:
if e.errorCode == 10 and e.parameter == 'Notebook.name':
self.storage.update(self.token, self.noteStore)
return True
else:
raise e
self.storage.create_notebook(notebook)
return True
def saveToEvernote(history):
EN_URL = 'https://sandbox.evernote.com'
dev_token = "S=s1:U=8d5df:E=14a1ce2575a:C=142c5312b5c:P=1cd:A=en-devtoken:V=2:H=c3fba302a245ad5e2aa489bc02b3b873"
client = EvernoteClient(token=dev_token)
userStore = client.get_user_store()
note_store = client.get_note_store()
note = Note()
note.title = "chat history"
note.content = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">'
content = ''
for line in history:
content += "<br>" + line + "</br>"
note.content += '<en-note>' + content + '</en-note>'
note = note_store.createNote(note)
print note.content
def getUserShardId(authToken, userStore):
"""
Get the User from userStore and return the user's shard ID
"""
try:
user = userStore.getUser(authToken)
except (EDAMUserException, EDAMSystemException), e:
print "Exception while getting user's shardID:"
print type(e), e
return None
if hasattr(user, 'shardId'):
return user.shardId
return None
def create_client(self, storage_name='evernote.dat'):
'''Create an instance of EN client and set auth_token.'''
# Try check if storage file exists
if os.path.isfile(storage_name) is True:
# Try to read it
try:
storage = open(storage_name, 'r')
auth_token = storage.read()
# We will need it for some methods
self.token = auth_token
try:
# NB: sandbox=False for production
client = EvernoteClient(token=auth_token, sandbox=False)
# Now try to get user_store if Exception is thrown fall
# back to reauthorization
user_store = client.get_user_store()
user = user_store.getUser().username
except Exception as e:
print('Authorization error: ', e)
print('Will need to re-authorize.')
client = self.authorize(storage_name)
except IOError as e:
print('Error while reading the auth token: ', e)
client = None
finally:
storage.close()
else:
# No storage found, we will need to authorize the app
# to get the token
client = self.authorize(storage_name)
return client
def wraps(*args, **kwargs):
client = EvernoteClient(token=current_app.config["PRODTOKEN"], sandbox=current_app.config["SANDBOX"])
noteStore = client.get_note_store()
userStore = client.get_user_store()
kwargs["userStore"] = userStore
kwargs["noteStore"] = noteStore
return func(*args, **kwargs)
class EvernoteWrapper(object):
"""A wrapper class around the EvernoteClient and friends"""
@staticmethod
def get_dev_token():
"""FIXME: When done with development, figure out the proper way to get Evernote access."""
return open(os.path.expanduser('~/evernote.devtoken'), 'r').read().rstrip()
def __init__(self):
self.client = EvernoteClient(token=self.get_dev_token(), sandbox=False)
user_store = self.client.get_user_store()
self.user = user_store.getUser()
self.note_store = self.client.get_note_store()
# find "Action-Pending" notebook
notebooks = self.note_store.listNotebooks()
self.action_pending = [n for n in notebooks if n.name == "Action-Pending"][0]
# collect all tags
self.tags = {t.name: t for t in self.note_store.listTags()}
self.tag_names = {t.guid: t.name for t in self.note_store.listTags()}
@property
def context_tag_names(self):
return sorted([key for key in self.tags.keys() if key.startswith('@')])
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 next_actions(self, level='1-Now', context='all'):
"""return a list of NextAction objects"""
context = '@' + context
if not context in self.tags.keys():
context = None
assert level in self.tags.keys(), 'Unknown level tag: %s' % level
assert len(level.split('-')) == 2, 'Not a level tag: %s' % level
# FIXME: maybe do some more checking here...
return [NextAction(note, self.user, level) for note in self.get_notes(level, context)]
def replace_tag(self, note_guid, old_tag, new_tag):
"""Update a note by replacing the old tag with the new tag"""
note = self.note_store.getNote(note_guid, True, True, True, True)
old_tag = self.tags[old_tag]
new_tag = self.tags[new_tag]
note.tagGuids = list((set(note.tagGuids) | {new_tag.guid}) - {old_tag.guid})
self.note_store.updateNote(note)
print(note.title)
class EverCode:
def __init__(self, Settings):
self._settings = Settings
self._token = self._settings.developer_token
def setClient(self):
self._client = EvernoteClient(token=self._token, sandbox=self._settings.sandbox)
self._userStore = self._client.get_user_store()
self._user = self._userStore.getUser()
self._noteStore = self._client.get_note_store()
self._notebooks = self._noteStore.listNotebooks()
'''
def login(self):
self._client = EvernoteClient(
consumer_key = self._settings.consumer_key,
consumer_secret = self._settings.consumer_secret,
sandbox=self._settings.sandbox
)
request_token = self._client.get_request_token('YOUR CALLBACK URL')
self._client.get_authorize_url(request_token)
access_token = self._client.get_access_token(
request_token['oauth_token'],
request_token['oauth_token_secret'],
request_token.GET.get('oauth_verifier', '')
)
self._token = access_token
'''
def makeNote(self, noteTitle, noteBody, parentNotebook=None):
result = noteBody.replace('class="highlight"', '')
nBody = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
nBody += "<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">"
nBody += "<en-note>%s</en-note>" % result
## Create note object
ourNote = Types.Note()
ourNote.title = noteTitle
ourNote.content = nBody
## parentNotebook is optional; if omitted, default notebook is used
if parentNotebook and hasattr(parentNotebook, 'guid'):
ourNote.notebookGuid = parentNotebook.guid
## Attempt to create note in Evernote account
try:
note = self._noteStore.createNote(self._token, ourNote)
except Errors.EDAMUserException, edue:
## Something was wrong with the note data
## See EDAMErrorCode enumeration for error code explanation
## http://dev.evernote.com/documentation/reference/Errors.html#Enum_EDAMErrorCode
print "EDAMUserException:", edue
return None
except Errors.EDAMNotFoundException, ednfe:
## Parent Notebook GUID doesn't correspond to an actual notebook
print "EDAMNotFoundException: Invalid parent notebook GUID"
return None
def connect2Ev(check=False):
client = EvernoteClient(token=DEV_TOKEN, sandbox=False)
if check:
userStore = client.get_user_store()
user = userStore.getUser()
print "Connected to user account %s" % user.username
noteStore = client.get_note_store()
return noteStore
def get_user(self, auth_token):
sdk = EvernoteSdk(token=auth_token, sandbox=self.sandbox)
user_store = sdk.get_user_store()
user = user_store.getUser(auth_token)
return {
'id': user.id,
'shard_id': user.shardId,
}
def fetch_evernote_notes():
global notes, title
from evernote.edam.notestore import NoteStore
from evernote.edam.userstore import constants as user_store_constants
from evernote.api.client import EvernoteClient
# Real applications authenticate with Evernote using OAuth, but for the
# purpose of exploring the API, you can get a developer token that allows
# you to access your own Evernote account. To get a developer token, visit
# https://sandbox.evernote.com/api/DeveloperToken.action
# sandbox
# sandbox_auth_token = \
# "xxx"
# Initial development is performed on our sandbox server. To use the production
# service, change sandbox=False and replace your
# developer token above with a token from
# https://www.evernote.com/api/DeveloperToken.action
# client = EvernoteClient(token=sandbox_auth_token, sandbox=True)
# original
production_auth_token = \
"xxxx"
evernote_client = EvernoteClient(token=production_auth_token, sandbox=False)
# get user store
user_store = evernote_client.get_user_store()
# check if API version is fine
version_ok = user_store.checkVersion(
"Evernote EDAMTest (Python)",
user_store_constants.EDAM_VERSION_MAJOR,
user_store_constants.EDAM_VERSION_MINOR
)
print "Is my Evernote API version up to date? ", str(version_ok)
if not version_ok:
exit(1)
# get notes store
note_store = evernote_client.get_note_store()
# search for the notebook named ideas
note_filter = NoteStore.NoteFilter()
note_filter.words = 'notebook:"{}"'.format(EVERNOTE_NOTEBOOK_NAME)
notes_metadata_result_spec = NoteStore.NotesMetadataResultSpec()
notes_metadata_list = note_store.findNotesMetadata(note_filter, 0, NUM_EVERNOTE_NOTES, notes_metadata_result_spec)
# get all the notes in the ideas notebook
notes = {}
print "Fetching notes..."
for note_metadata in notes_metadata_list.notes:
note_guid = note_metadata.guid
# fetch complete note
note = note_store.getNote(note_guid, True, True, False, False)
title = note.title
notes[title] = note.content
if None != note.resources:
print "resources are present for card: {}".format(title)
return notes
def handle(text, mic, profile):
auth_token = profile["EVERNOTE_TOKEN"]
client = EvernoteClient(token=auth_token, sandbox=False)
user_store = client.get_user_store()
note_store = client.get_note_store()
if bool(re.search(r'\Note\b', text, re.IGNORECASE)):
writeNote(text, mic, note_store)
def handle(text, mic, profile):
auth_token = profile["EVERNOTE_TOKEN"]
client = EvernoteClient(token=auth_token, sandbox=False)
user_store = client.get_user_store()
note_store = client.get_note_store()
if bool(re.search(r"\Note\b", text, re.IGNORECASE)):
writeNote(text, mic, note_store)
def setup(): #login to the evernote test server testclient = EvernoteClient(token=auth_token, sandbox=True) user_store = testclient.get_user_store() note_store = testclient.get_note_store() testuser = user_store.getUser() assert_equal(testuser.username, "silver97232") assert_not_equal(testuser.username, "made up username, should fail") print "SETUP!" print client
class EvernoteBookmarks(object):
def __init__(self, token):
self.token = token
self.client = EvernoteClient(
token=token,
sandbox=False)
self.user_store = self.client.get_user_store()
version_ok = self.user_store.checkVersion(
"Evernote EDAMTest (Python)",
UserStoreConstants.EDAM_VERSION_MAJOR,
UserStoreConstants.EDAM_VERSION_MINOR
)
if not version_ok:
raise ValueError("Evernote API version not up to date")
self.note_store = self.client.get_note_store()
def list_notebooks(self):
return self.note_store.listNotebooks()
def create_notebook(self, notebook_name):
notebook = Types.Notebook()
notebook.name = notebook_name
notebook = self.note_store.createNotebook(notebook)
return notebook.guid
def create_note(self, bookmark, notebook_guid):
date_created = bookmark['add_date']*1000
tag_string = ', '.join(bookmark['tags'])
if 'no_tag' in tag_string:
tag_string = ""
content = NOTE_TEMPLATE.format(
title=cgi.escape(bookmark['title']),
url=cgi.escape(bookmark['url']),
tags=cgi.escape(tag_string),
last_visit=cgi.escape(str(datetime.fromtimestamp(bookmark['last_visit']))),
add_date=cgi.escape(str(datetime.fromtimestamp(bookmark['add_date']))),
private=cgi.escape("Yes" if bookmark['private'] else "No"),
)
note = Types.Note()
note.title = bookmark['title'].encode('utf-8')
note.content = content.encode('utf-8')
note.tagNames = [bm.encode('utf-8') for bm in bookmark['tags']]
note.created = date_created
note.updated = date_created
note.notebookGuid = notebook_guid
self.note_store.createNote(note)
class EvernoteBookmarks(object):
def __init__(self, token):
self.token = token
self.client = EvernoteClient(token=token, sandbox=False)
self.user_store = self.client.get_user_store()
version_ok = self.user_store.checkVersion(
"Evernote EDAMTest (Python)",
UserStoreConstants.EDAM_VERSION_MAJOR,
UserStoreConstants.EDAM_VERSION_MINOR)
if not version_ok:
raise ValueError("Evernote API version not up to date")
self.note_store = self.client.get_note_store()
def list_notebooks(self):
return self.note_store.listNotebooks()
def create_notebook(self, notebook_name):
notebook = Types.Notebook()
notebook.name = notebook_name
notebook = self.note_store.createNotebook(notebook)
return notebook.guid
def create_note(self, bookmark, notebook_guid):
date_created = bookmark['add_date'] * 1000
tag_string = ', '.join(bookmark['tags'])
if 'no_tag' in tag_string:
tag_string = ""
content = NOTE_TEMPLATE.format(
title=cgi.escape(bookmark['title']),
url=cgi.escape(bookmark['url']),
tags=cgi.escape(tag_string),
last_visit=cgi.escape(
str(datetime.fromtimestamp(bookmark['last_visit']))),
add_date=cgi.escape(
str(datetime.fromtimestamp(bookmark['add_date']))),
private=cgi.escape("Yes" if bookmark['private'] else "No"),
)
note = Types.Note()
note.title = bookmark['title'].encode('utf-8')
note.content = content.encode('utf-8')
note.tagNames = [bm.encode('utf-8') for bm in bookmark['tags']]
note.created = date_created
note.updated = date_created
note.notebookGuid = notebook_guid
self.note_store.createNote(note)
class EvernoteAPI:
def __init__(self):
config = ConfigHandler('evernote.config')
token = config.get('one-calendar', 'token')
self.client = EvernoteClient(token=token)
def user_store(self):
return self.client.get_user_store()
def note_store(self):
return self.client.get_note_store()
def yx():
"""
测试印象笔记服务
:return:
"""
client = EvernoteClient(token=dev_token,sandbox=False)
client.service_host = 'app.yinxiang.com'
userStore = client.get_user_store()
user = userStore.getUser()
print user
return "yx"
def SignInEvernote():
global client,noteStore
result = False
try:
client = EvernoteClient(token=dev_token)
userStore = client.get_user_store()
user = userStore.getUser() # here will throw an error
logging.info(user.username)
noteStore = client.get_note_store()
result = True
except Exception, e:
logging.warn(e)
def __init__(self, token, notebook_guid=None):
"""
:param str token: The Evernote auth token
:param str notebook_guid: The Evernote notebook GUID or None if not known
"""
client = EvernoteClient(token=token,
consumer_key=EVERNOTE_CONSUMER_KEY,
consumer_secret=EVERNOTE_CONSUMER_SECRET,
sandbox=DEVELOPMENT_MODE)
self._token = token
self._note_store_uri = client.get_user_store().getNoteStoreUrl()
self._thread_pool = ThreadPool(processes=EVERNOTE_FETCH_THREADS)
self.notebook_guid = notebook_guid or self._get_create_notebook()
def get_quota_info(self, auth_token):
sdk = EvernoteSdk(token=auth_token, sandbox=self.sandbox)
user_store = sdk.get_user_store()
note_store = self.get_note_store(auth_token)
user = user_store.getUser()
state = note_store.getSyncState()
total_monthly_quota = user.accounting.uploadLimit
used_so_far = state.uploaded
quota_remaining = total_monthly_quota - used_so_far
reset_date = datetime.datetime.fromtimestamp(user.accounting.uploadLimitEnd / 1000.0)
return {
'remaining': quota_remaining,
'reset_date': reset_date,
}
class Evernote():
logger = logging.getLogger('Evernote')
def __init__(self, auth_token, NOTEBOOK):
#authentication
self.client = EvernoteClient(token=auth_token, sandbox=False)
self.userStore = self.client.get_user_store()
self.noteStore = self.client.get_note_store()
self.NOTEBOOK = NOTEBOOK
self.tags = self.noteStore.listTags()
def addNote(self, entry, notebook=None):
'''
adds a note (title, content) to the standard Notebook
'''
if notebook == None:
notebook = self.NOTEBOOK
note = Types.Note()
note.notebookGuid = notebook
note.title = entry['title'].replace(' ', '')
if note.title == '':
note.title = 'RedNotebookEntry'
note.content = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">'
note.content += '<en-note>%s</en-note>' % transformContent(
entry['content'])
note = self.noteStore.createNote(note)
logger.info('added note:%s, with guid:%s' %
(entry['title'], str(note.guid)))
return note.guid
def addNotebook(self, notebookname):
'''
adds a Notebook to the noteStore if needed(to store all Rednotebook entries)
'''
notebook = Types.Notebook()
notebook.name = notebookname
notebook = self.noteStore.createNotebook(notebook)
logger.info('added notebook:%s, with guid:%s' %
(notebookname, str(notebook.guid)))
return notebook.guid
def CheckVersion(self):
version_ok = self.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 ""
return version_ok
class Evernote_Poster(object):
'''Post notes to evernote'''
def __init__(self, token):
self.token = token
self.client = EvernoteClient(token=EN_TOKEN, sandbox=False)
self.user_store = self.client.get_user_store()
self.note_store = self.client.get_note_store()
def check_version(self):
'''Check for version'''
version_ok = self.user_store.checkVersion(
"Version check",
UserStoreConstants.EDAM_VERSION_MAJOR,
UserStoreConstants.EDAM_VERSION_MINOR
)
if not version_ok:
return -1
else:
return 0
def _make_note(self, title, content, url):
'''Prepare a note to be posted'''
note = Types.Note()
note.title = title
# Set up note attributes
attrs = Types.NoteAttributes()
attrs.sourceURL = url
note.attributes = attrs
note.content = '<?xml version="1.0" encoding="UTF-8"?>'
note.content += '<!DOCTYPE en-note SYSTEM ' \
'"http://xml.evernote.com/pub/enml2.dtd">'
# Wrap content in <en-note>
note.content += '<en-note>'
note.content += content
note.content += '</en-note>'
return note
def post_note(self, title, note, url):
'''Post a note to Evernote'''
ver = self.check_version()
if ver < 0:
print('*** VERSION ERROR: Update client to the latest version.')
else:
note = self._make_note(title, note, url)
created_note = self.note_store.createNote(note)
return created_note.guid
def __init__(self, token, notebook_name='default'):
"""
Initializes the evernote client for uploading notes.
:param token: the developer token needed for access to the account
:type token: str
:param notebook_name: name of notebook to add the new notes to.
:type notebook_name: str
"""
self.logger = logging.getLogger(__name__)
self.logger.info("Initializing Evernote client")
client = None
try: # Should make sandbox a debug option
client = EvernoteClient(token=token, sandbox=False)
except evernote.edam.error.ttypes.EDAMUserException:
print("Please provide correct evernote credentials")
if input(
"Abort (y/n): "
) == 'y': # Might be best to just silently try again or continue rather than ask.
raise SystemExit
self.user_store = client.get_user_store()
self.note_store = client.get_note_store()
self.tag_list = self.note_store.listTags()
self.notebooks = self.note_store.listNotebooks()
self.notebook_name = notebook_name # for use in other functions.
self.notebook_guid = None
self.error_count = 0
self.warning_count = 0
self.quota_remaining()
if notebook_name != 'default': # ie we want to specify the notebook to save the notes to
notebook_dic = {}
for notebook in self.notebooks: # create dict of notebook names: notebook objects
notebook_dic[notebook.name] = notebook
if notebook_name in notebook_dic: # if notebook exists, set persistant guid as existing guid
self.notebook_guid = notebook_dic[notebook_name].guid
else: # if it doesn't exist, create it.
new_notebook = Types.Notebook()
new_notebook.name = notebook_name
new_notebook.defaultNotebook = False
self.notebook_guid = self.note_store.createNotebook(
new_notebook).guid
self.note = None
def upload_shopping_list():
shopping_list = open_shopping_list()
dev_token = "S=s1:U=94a8d:E=16b12ef7476:C=163bb3e4778:P=1cd:A=en-devtoken:V=2:H=597dbf9724fbc184e2d5b1eced891761"
client = EvernoteClient(token=dev_token)
userStore = client.get_user_store()
noteStore = client.get_note_store()
note = ttypes.Note()
note.title = 'Shopping list ' + str(datetime.date.today())
body = '<?xml version="1.0" encoding="UTF-8"?>'
body += '<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">'
body += '<en-note>'
for item in set(shopping_list["items"]):
body += '<div><en-todo/> %d %s</div>' % (shopping_list["items"][item],
item)
body += '</en-note>'
note.content = body
noteToUpload = noteStore.createNote(dev_token, note)
def _init_network(self):
"""Init connection to remote server"""
logger.debug("Execute _init_network")
while True:
try:
# pull token from keyring
logger.debug("init network auth_token")
self.auth_token = get_auth_token( )
# use EvernoteClient() to get userstore and notestore
client = EvernoteClient(token=self.auth_token, sandbox=False)
self.user_store = client.get_user_store()
self.note_store = client.get_note_store()
# self.note_store = tools.get_note_store(self.auth_token)
# self.user_store = tools.get_user_store(self.auth_token)
break
except EDAMSystemException, e:
if e.errorCode == EDAMErrorCode.RATE_LIMIT_REACHED:
logger.error(
"Rate limit _init_network: %d minutes - sleeping" %
(e.rateLimitDuration/60)
)
self.status = const.STATUS_RATE
# nothing I can think of doing other than sleeping here
# until the rate limit clears
time.sleep(e.rateLimitDuration)
self.status = const.STATUS_NONE
except socket.error, e:
logger.error(
"Couldn't connect to remote server. Got: %s" %
traceback.format_exc()
)
SyncStatus.connect_error_count+=1
logger.error(
"Total connect errors: %d" % SyncStatus.connect_error_count)
time.sleep(30)
class EvernoteModule(BaseModule):
def __init__(self, *args):
super(EvernoteModule, self).__init__(*args)
self.auth_token = self.get_configuration('evernote_auth_token')
if self.auth_token:
self.client = EvernoteClient(token=self.auth_token, sandbox=False)
self.user_store = self.client.get_user_store()
self.note_store = self.client.get_note_store()
else:
return False
def write_note(self):
note = NoteType.Note() # Creates a new note
note.title = "Stephanie Note"
self.assistant.say("What would you like me to write down?")
the_note = self.assistant.listen().decipher() # Listens to the input and stores it
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:<br/>'
note.content += ('%s' % the_note)
note.content += '</en-note>'
try:
created_note = self.note_store.createNote(note) # Stores the new note in Evernote
except:
response = ("Note wasn't created successfully, you probably didn't spelled anything or spelled really "
"bad, Not my fault okay? It's never a program's fault.")
print(response)
return response
if created_note:
return "I successfully wrote down your note."
else:
response = ("Note wasn't created successfully, you probably didn't spelled anything or spelled really "
"bad, Not my fault okay? It's never a program's fault. /s Refer back to docs.")
print(response)
return response
class EvernoteModule(BaseModule):
def __init__(self, *args):
super(EvernoteModule, self).__init__(*args)
self.auth_token = self.get_configuration('evernote_auth_token')
if self.auth_token:
self.client = EvernoteClient(token=self.auth_token, sandbox=False)
self.user_store = self.client.get_user_store()
self.note_store = self.client.get_note_store()
else:
return False
def write_note(self):
note = NoteType.Note() # Creates a new note
note.title = "Stephanie Note"
self.assistant.say("What would you like me to write down?")
the_note = self.assistant.listen().decipher(
) # Listens to the input and stores it
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:<br/>'
note.content += ('%s' % the_note)
note.content += '</en-note>'
try:
created_note = self.note_store.createNote(
note) # Stores the new note in Evernote
except:
response = (_("error.note.create"))
print(response)
return response
if created_note:
return _("note.create.success")
else:
response = (_("error.note.create"))
print(response)
return response
def get_source_urls(auth_token):
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()
# get all notes tagged 'beek'
filter = NoteStore.NoteFilter()
filter.words = "tag:beek"
filter.ascending = False
spec = NoteStore.NotesMetadataResultSpec()
spec.includeTitle = True
ourNoteList = note_store.findNotesMetadata(auth_token, filter, 0, 100,
spec)
wholeNotes = []
urls_and_contents = []
for note in ourNoteList.notes:
share_url = shareSingleNote(auth_token, note_store, user_store,
note.guid)
wholeNote = note_store.getNote(auth_token, note.guid, True, False,
False, False)
urls_and_contents.append((share_url, wholeNote))
return (note_store, urls_and_contents)
def retrieve_tags_and_note_collection_counts(auth_token, sandbox, note_filter):
"""Uses the Evernote API to retrieve tags and note collection counts
Args:
auth_token (str): the Evernote API authentication token
sandbox (bool): sandbox flag, indicates whether Evernote API calls should be made against the production or sandbox environment
note_filter (evernote.edam.notestore.ttypes.NoteFilter): the filter applied to the search query on the Evernote API
Returns:
evernote.edam.type.ttypes.Tag: list of tags in the Evernote acccount
evernote.edam.notestore.ttypes.NoteCollectionCounts: number of notes for each notebook and tag with a non-zero set of applicable notes
"""
try:
client = EvernoteClient(token=auth_token, sandbox=sandbox)
user_store = client.get_user_store()
user = user_store.getUser()
logging.info(
"Retrieving tags and noteCollectionCounts for Evernote user [%s]%s",
user.username, " from sandbox environment" if sandbox else "")
note_store = client.get_note_store()
tags = note_store.listTags()
note_collection_counts = note_store.findNoteCounts(note_filter, False)
logging.info(
"Retrieved [%d] tags and [%d] noteCollectionCounts from Notes of user [%s]",
len(tags), len(note_collection_counts.tagCounts), user.username)
return tags, note_collection_counts
except EDAMSystemException as e:
logging.error(
"Failed to retrieve tags and noteCollectionCounts from Evernote API: %s",
EDAMErrorCode._VALUES_TO_NAMES[e.errorCode])
raise
except EDAMUserException as e:
logging.error(
"Failed to retrieve tags and noteCollectionCounts from Evernote API: %s",
EDAMErrorCode._VALUES_TO_NAMES[e.errorCode])
raise
class Sync(object):
token = "S=s245:U=1e2f5ee:E=15ce321c571:C=1558b709860:P=1cd:A=en-devtoken:V=2:H=bd15150c522ef2489eb5a0fe88d86f51"
def __init__(self, token=None):
self.client = None
self.is_authenticated = None
if token:
self.token = token
def get_client(self):
self.is_authenticated = self._connect_to_evernote(self.token)
return self.client
def _connect_to_evernote(self, dev_token):
user = None
try:
self.client = EvernoteClient(token=dev_token, sandbox=False)
user_store = self.client.get_user_store()
user = user_store.getUser()
except EDAMUserException as e:
err = e.errorCode
print("Error attempting to authenticate to Evernote: %s - %s" %
(EDAMErrorCode._VALUES_TO_NAMES[err], e.parameter))
return False
except EDAMSystemException as e:
err = e.errorCode
print("Error attempting to authenticate to Evernote: %s - %s" %
(EDAMErrorCode._VALUES_TO_NAMES[err], e.message))
sys.exit(-1)
if user:
print("Authenticated to evernote as user %s" % user.username)
return True
else:
return False
def get_token(self):
return self.token