def nb_list(self):
if not self.logged_in:
self.response.status = '401 Unauthorized'
return
if not self.current_user.active:
self.response.status = '401 Unauthorized'
return
unit = Unit.get_by_user_key(self.current_user.key)
if unit.token == '':
self.response.status = '401 Unauthorized'
return
if unit.notebook_guid is not None:
self.response.status = '401 Unauthorized'
return
client = helper.get_evernote_client(token=unit.token)
try:
note_store = client.get_note_store()
notebooks = note_store.listNotebooks()
except (EDAMUserException, EDAMSystemException) as e:
logging.error("Evernote API Error: %s on %s." % (e.errorCode, e.parameter))
if e.errorCode == EDAMErrorCode._NAMES_TO_VALUES['AUTH_EXPIRED']:
unit = unit.key.get()
unit.token = ''
unit.put()
self.response.status = '401 Unauthorized'
self.response.write('Evernote Authorization Expired')
return
self.response.status = '500 Internal Server Error'
self.response.write('Evernote Connection Error')
return
json_vars = { 'notebooks': [] }
for nb in notebooks:
json_vars['notebooks'].append({ 'name': nb.name, 'guid': nb.guid })
self.render_json(json_vars)
return
def get(self):
if not self.logged_in:
self.redirect('/')
try:
client = helper.get_evernote_client()
token = client.get_access_token(
self.session.get('oauth_token'),
self.session.get('oauth_token_secret'),
self.request.get('oauth_verifier')
)
except KeyError:
self.session.add_flash(False, level='en', key='connect')
logging.error('Failed to retrieve access token data in call back function.')
return self.redirect('/settings')
if not self.update_info(client, self.current_user, token):
self.session.add_flash(False, level='en', key='connect')
logging.error('Failed to working on unit.')
return self.redirect('/settings')
self.session.add_flash(True, level='en', key='connect')
return self.redirect('/settings')
def get(self):
if not self.logged_in:
self.redirect('/')
unit = Unit.get_by_user_key(self.current_user.key)
if unit is not None and unit.token != '':
return self.redirect("/settings")
client = helper.get_evernote_client()
callbackUrl = 'http://%s/auth/evernote/callback' % self.request.host
request_token = client.get_request_token(callbackUrl)
# Save the request token information for later
try:
self.session['oauth_token'] = request_token['oauth_token']
self.session['oauth_token_secret'] = request_token['oauth_token_secret']
except KeyError:
self.session.add_flash(False, level='en', key='connect')
logging.error('Failed to retrieve access token data in auth function.')
return self.redirect('/settings')
# Redirect the user to the Evernote authorization URL
return self.redirect(client.get_authorize_url(request_token))
def creatNotebook(self, unit=None, response=True):
if not self.logged_in:
self.response.status = '401 Unauthorized'
return
if not self.current_user.active:
self.response.status = '401 Unauthorized'
return
if unit is None:
unit = Unit.get_by_user_key(user.key)
try:
client = helper.get_evernote_client(token=unit.token)
note_store = client.get_note_store()
except EDAMUserException as e:
logging.error('Evernote Error: %s %s, parm: %s' % (str(e.errorCode), EDAMErrorCode._VALUES_TO_NAMES[e.errorCode], e.parameter))
if response:
self.response.status = '500 Internal Server Error'
return False
except EDAMSystemException as e:
logging.error('Evernote Error: %s %s, msg: %s' % (str(e.errorCode), EDAMErrorCode._VALUES_TO_NAMES[e.errorCode], e.message))
if response:
self.response.status = '500 Internal Server Error'
return False
retry = 0
while unit.notebook_guid is None or unit.notebook_guid == '':
if retry >= 3:
name = 'Knonce %s' % helper.code_generator(5)
elif retry > 0:
name = 'Knonce %s' % str(retry)
else:
name = 'Knonce'
try:
nb = Notebook(name=name)
nb = note_store.createNotebook(unit.token, nb)
except (EDAMUserException, EDAMSystemException) as e:
if e.errorCode == EDAMErrorCode._NAMES_TO_VALUES['DATA_CONFLICT'] and e.parameter == 'Notebook.name':
logging.info('Evernote Error: %s %s, parm: %s' % (str(e.errorCode), EDAMErrorCode._VALUES_TO_NAMES[e.errorCode], e.parameter))
retry += 1
if retry > 5:
if response:
self.response.status = '500 Internal Server Error'
return False
continue
else:
logging.error('Evernote Error: %s %s, parm: %s' % (str(e.errorCode), EDAMErrorCode._VALUES_TO_NAMES[e.errorCode], e.parameter))
if response:
self.response.status = '500 Internal Server Error'
return False
break
if nb.guid is None:
if response:
self.response.status = '500 Internal Server Error'
return False
try:
nb = note_store.getNotebook(unit.token, nb.guid)
except (EDAMUserException, EDAMSystemException) as e:
logging.error('Evernote Error: %s %s, parm: %s' % (str(e.errorCode), EDAMErrorCode._VALUES_TO_NAMES[e.errorCode], e.parameter))
if response:
self.response.status = '500 Internal Server Error'
return False
except EDAMNotFoundException as e:
logging.error('EDAMNotFound identifier: %s, key: %s' % (exception.identifier, exception.key))
if response:
self.response.status = '500 Internal Server Error'
return False
unit.notebook_name = nb.name
unit.notebook_guid = nb.guid
unit.put()
return True
def nb_name(self):
if not self.logged_in:
self.response.status = '401 Unauthorized'
return
if not self.current_user.active:
self.response.status = '401 Unauthorized'
return
unit = Unit.get_by_user_key(self.current_user.key)
if unit.token == '':
self.response.status = '401 Unauthorized'
return
if unit.status == UnitStatus.NotebookNotExist:
self.response.status = '404 Not Found'
self.response.write('Notebook Not Found')
return
if unit.notebook_guid is None or unit.notebook_guid == '':
self.creatNotebook(unit, False)
client = helper.get_evernote_client(token=unit.token)
try:
note_store = client.get_note_store()
notebook = note_store.getNotebook(unit.token, unit.notebook_guid)
except (EDAMUserException, EDAMSystemException) as e:
if hasattr(e, 'parameter'):
logging.error("Evernote API Error: %s %s on %s." % (e.errorCode, EDAMErrorCode._VALUES_TO_NAMES[e.errorCode], e.parameter))
elif hasattr(e, 'message'):
logging.error('Evernote Error: %s %s, msg: %s' % (str(e.errorCode), EDAMErrorCode._VALUES_TO_NAMES[e.errorCode], e.message))
if e.errorCode == EDAMErrorCode._NAMES_TO_VALUES['AUTH_EXPIRED']:
unit = unit.key.get()
unit.token = ''
unit.put()
self.response.status = '401 Unauthorized'
self.response.write('Evernote Authorization Expired')
return
self.response.status = '500 Internal Server Error'
self.response.write('Evernote Connection Error')
return
except EDAMNotFoundException as e:
logging.error("EDAMNotFound: %s on %s." % (e.identifier, e.key))
if e.identifier == 'Notebook.guid':
unit = unit.key.get()
unit.status = UnitStatus.NotebookNotExist
unit.put()
self.response.status = '404 Not Found'
self.response.write('Notebook Not Found')
return
self.response.status = '500 Internal Server Error'
self.response.write('Evernote Connection Error')
return
if unit.notebook_name != notebook.name:
unit.notebook_name = notebook.name
unit.put()
self.render_json({'name': notebook.name})
def note(self):
""" verify parameters """
names = ['user_id', 'guid', 'reason']
for name in names:
if self.request.get(name) is None or self.request.get(name) == '':
logging.error('en-note-guid = %s, not enough parameters.' % self.request.get('guid'))
return
""" get unit info """
try:
unit_arr = Unit.query(Unit.user_id==int(self.request.get('user_id'))).fetch(1, projection=['notebook_guid', 'token', 'status'])
except ValueError:
logging.error('en-user-id = %s, wrong user_id format.' % self.request.get('user_id'))
return
if len(unit_arr) <= 0:
logging.info('en-note-guid = %s, unit don\t exist in database.' % self.request.get('guid'))
return
unit = unit_arr[0]
if unit.token is None or unit.token == '':
logging.info('en-note-guid = %s, unit token is none.' % self.request.get('guid'))
return
if unit.status != UnitStatus.Active:
logging.info('en-note-guid = %s, unit not active.' % self.request.get('guid'))
return
""" get note metadata """
try:
client = helper.get_evernote_client(token=unit.token)
note_store = client.get_note_store()
en_note = note_store.getNote(unit.token, self.request.get('guid'), False, False, False, False)
except (EDAMUserException, EDAMSystemException) as e:
return self.en_user_system_exception(unit, e, self.request.get('guid'))
except EDAMNotFoundException as e:
return self.en_not_found_exception(e, self.request.get('guid'))
""" start sync """
if self.request.get('reason') == 'create':
""" check notebook """
if en_note.notebookGuid != unit.notebook_guid:
""" skip sync """
logging.info('skipped: not in notebook')
return
""" check length """
if en_note.contentLength > SyncSettings.max_length:
""" skip sync """
logging.info('skipped: length exceed limit, do not create note')
return
""" SYNC: create a new note """
try:
en_content = note_store.getNoteContent(unit.token, self.request.get('guid'))
except (EDAMUserException, EDAMSystemException) as e:
return self.en_user_system_exception(unit, e, self.request.get('guid'))
except EDAMNotFoundException as e:
return self.en_not_found_exception(e, self.request.get('guid'))
self.make_note(None, unit, en_note, en_content)
logging.info('en-note-guid = %s, created and synced.' % self.request.get('guid'))
elif self.request.get('reason') == 'update':
note = ndb.Key(flat=list(unit.key.flat())+['Note', 'en-%s' % en_note.guid]).get()
if en_note.notebookGuid == unit.notebook_guid:
if note is not None:
if en_note.deleted is not None:
""" deleted """
note.key.delete()
logging.info('en-note-guid = %s, deleted from notebook.' % self.request.get('guid'))
return
if en_note.contentLength > SyncSettings.max_length:
""" check length """
note.key.delete()
logging.info('skipped: length exceed limit, delete current note')
return
else:
if note is None:
logging.info('note is none %s'%str(list(unit.key.flat())+['Note', 'en-%s'%en_note.guid]))
return
if en_note.deleted is not None:
""" deleted """
note.key.delete()
logging.info('en-note-guid = %s, deleted from notebook.' % self.request.get('guid'))
return
elif en_note.notebookGuid != unit.notebook_guid:
""" moved to other notebook """
note.key.delete()
logging.info('en-note-guid = %s, delete note since moved out of notebook.' % self.request.get('guid'))
return
else:
""" moved to other notebook """
note.key.delete()
logging.warning('en-note-guid = %s, action cause note to be deleted.' % self.request.get('guid'))
return
try:
en_content = note_store.getNoteContent(unit.token, self.request.get('guid'))
except (EDAMUserException, EDAMSystemException) as e:
return self.en_user_system_exception(unit, e, self.request.get('guid'))
except EDAMNotFoundException as e:
return self.en_not_found_exception(e, self.request.get('guid'))
""" SYNC: check if the note is in database, if not, create one """
add = False
if note is None:
add = True
""" MAKE NOTE """
self.make_note(note, unit, en_note, en_content)
if add:
logging.info('en-note-guid = %s, created and synced in update.' % self.request.get('guid'))
else:
logging.info('en-note-guid = %s, synced.' % self.request.get('guid'))
