def getUserStoreInstance(authToken): print "Getting UserStore instance..." userStoreUri = "%s/edam/user" % EN_URL userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol(userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) return userStore
def __init__(self, config): self.config = config self.authToken = config["access_token"] ''' Initial development is performed on our sandbox server. To use the production service, change "sandbox.evernote.com" to "www.evernote.com" and replace your developer token above with a token from https://www.evernote.com/api/DeveloperToken.action ''' self.evernoteHost = "sandbox.evernote.com" userStoreUri = "https://" + self.evernoteHost + "/edam/user" userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol( userStoreHttpClient) self.userStore = UserStore.Client(userStoreProtocol) ''' Get the URL used to interact with the contents of the user's account When your application authenticates using OAuth, the NoteStore URL will be returned along with the auth token in the final OAuth request. In that case, you don't need to make this call. ''' noteStoreUrl = self.userStore.getNoteStoreUrl(self.authToken) #print noteStoreUrl noteStoreHttpClient = THttpClient.THttpClient(noteStoreUrl) noteStoreProtocol = TBinaryProtocol.TBinaryProtocol( noteStoreHttpClient) self.noteStore = NoteStore.Client(noteStoreProtocol)
def get_user_store(self): user_store_uri = self._get_endpoint("/edam/user") store = Store(self.token, UserStore.Client, user_store_uri) if not store: # Trick for PyDev code completion store = UserStore.Client() raise Exception('Should never reach here') return store
def _connect(username, password): try: userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol( userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) authresult = userStore.authenticate(username, password, consumer_key, consumer_secret) if authresult: token = authresult.authenticationToken noteStoreUrl = authresult.noteStoreUrl if not settings.get( "password") and sublime.ok_cancel_dialog( "Remember password?"): settings.set("password", password) settings.set("username", username) settings.set("authToken", token) settings.set("noteStoreUrl", noteStoreUrl) sublime.save_settings('SublimeEvernote.sublime-settings') sublime.status_message("authenticate ok") callback(**kwargs) else: raise Exception("authenticate failure") except Exception, e: sublime.error_message("error:%s" % e)
def __init__(self, username, password, consumerKey, consumerSecret, userStoreUri, noteStoreUriBase): self.username = username self.password = password # setup the basic connection stuff userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol( userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) versionOK = userStore.checkVersion( "Python EDAMTest", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) if not versionOK: raise ErrorConstants.EDAMSystemException( ErrorConstants.EDAMErrorCode.UNKNOWN, "EDAM protocol version not up to date ") authResult = userStore.authenticate(username, password, consumerKey, consumerSecret) user = authResult.user self.authToken = authResult.authenticationToken noteStoreUri = noteStoreUriBase + user.shardId noteStoreHttpClient = THttpClient.THttpClient(noteStoreUri) noteStoreProtocol = TBinaryProtocol.TBinaryProtocol( noteStoreHttpClient) self.noteStore = NoteStore.Client(noteStoreProtocol) self.getNotebooks(None)
def getUserStore(self): userStoreHttpClient = THttpClient.THttpClient( self.EN_USERSTORE_URIBASE) userStoreProtocol = TBinaryProtocol.TBinaryProtocol( userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) return userStore
def get_note_store(): userStoreHttpClient = THttpClient.THttpClient(config.user_store_uri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol(userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) noteStoreUrl = userStore.getNoteStoreUrl(config.auth_token) noteStoreHttpClient = THttpClient.THttpClient(noteStoreUrl) noteStoreProtocol = TBinaryProtocol.TBinaryProtocol(noteStoreHttpClient) return NoteStore.Client(noteStoreProtocol)
def recv_getNoteStoreUrl(self, ): (fname, mtype, rseqid) = self._iprot.readMessageBegin() if mtype == TMessageType.EXCEPTION: x = UserStore.TApplicationException() x.read(self._iprot) self._iprot.readMessageEnd() raise x result = getNoteStoreUrl_result() result.read(self._iprot) self._iprot.readMessageEnd() if result.success is not None: return result.success if result.userException is not None: raise result.userException if result.systemException is not None: raise result.systemException raise UserStore.TApplicationException( UserStore.TApplicationException.MISSING_RESULT, "getNoteStoreUrl failed: unknown result")
def get_note_store(): user_store_uri = "https://" + evernote_host + "/edam/user" user_store_http_client = THttpClient.THttpClient(user_store_uri) user_store_protoclo = TBinaryProtocol.TBinaryProtocol(user_store_http_client) user_store = UserStore.Client(user_store_protoclo) note_store_url = user_store.getNoteStoreUrl(auth_token) note_store_http_client = THttpClient.THttpClient(note_store_url) note_store_protocol = TBinaryProtocol.TBinaryProtocol(note_store_http_client) return NoteStore.Client(note_store_protocol)
def get_user_store(auth_token=None): if not auth_token: auth_token = get_auth_token() user_store_uri = "https://" + HOST + "/edam/user" user_store_http_client = THttpClient.THttpClient( user_store_uri, http_proxy=get_proxy_config(urlparse(user_store_uri).scheme)) user_store_protocol = TBinaryProtocol.TBinaryProtocol( user_store_http_client) return UserStore.Client(user_store_protocol)
def wraps(*args, **kwargs): user_store_http_client = THttpClient(settings.EVERNOTE_STORE_URI) user_store_protocol = TBinaryProtocol(user_store_http_client) user_store = UserStore.Client(user_store_protocol) note_store_url = user_store.getNoteStoreUrl( settings.EVERNOTE_DEVELOPER_TOKEN) note_store_http_client = THttpClient(note_store_url) note_store_protocol = TBinaryProtocol(note_store_http_client) note_store = NoteStore.Client(note_store_protocol) kwargs['user_store'] = user_store kwargs['note_store'] = note_store return func(*args, **kwargs)
def create_user_store(self): uri = "https://" + Evernote.HOST + "/edam/user" http_client = THttpClient.THttpClient(uri) protocol = TBinaryProtocol.TBinaryProtocol(http_client) user_store = UserStore.Client(protocol) version_ok = user_store.checkVersion( "Python EDAMTest", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) if not version_ok: raise StandardError("EDAM version error") return user_store
def getAuth(self, user, password): userStoreHttpClient = THttpClient.THttpClient(self.userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol(userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) versionOK = userStore.checkVersion("Python EDAMTest", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) if not versionOK: print "Old EDAM version" exit(1) authResult = userStore.authenticate(user, password, self.consumerKey, self.consumerSecret) user = authResult.user self.authToken = authResult.authenticationToken self.authResult = authResult return self.authToken
def login_evernote_token(request): """ as get_evernote_token(), but logs the user in as well """ everAuth = EvernoteAPI() credentials = everAuth.get_user_token(request) if not credentials: return HttpResponseRedirect( reverse('account.views.login_page', args=[])) if request.user.is_authenticated(): user = request.user else: evernoteHost = settings.EVERNOTE_HOST userStoreUri = "https://" + evernoteHost + "/edam/user" userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol( userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) evernoteUser = userStore.getUser(credentials['oauth_token']) user = authenticate(username=evernoteUser.username, password=str(evernoteUser.id)) if not user: newUser = User.objects.create_user(evernoteUser.username, evernoteUser.email, str(evernoteUser.id)) names = evernoteUser.name.split() if evernoteUser.name else None newUser.first_name = names[0] if names and len(names) > 0 else "" newUser.last_name = names[1] if names and len(names) > 1 else "" newUser.save() user = authenticate(username=evernoteUser.username, password=str(evernoteUser.id)) login(request, user) try: expires_time = datetime.fromtimestamp(int(credentials['expires'])) except TypeError: logging.error("Error parsing token expires time") expires_time = datetime.now() profile = UserProfile() profile.user = user profile.evernote_token = credentials['oauth_token'] profile.evernote_token_expires_time = expires_time profile.evernote_note_store_url = credentials['edam_noteStoreUrl'] profile.save() return HttpResponseRedirect(reverse('base.views.index', args=[]))
def post(self): # check if we have session info session = get_current_session() if not (session.is_active()) or not (session["done"]): raise Exception("Session is not active") post = self.request.get("post") loc_lat = self.request.get("loc_lat") loc_long = self.request.get("loc_long") local_time_stamp = self.request.get("time") # set up the thrift userStore userStoreHttpClient = THttpClient.THttpClient(USERSTORE_URI) userStoreProtocol = TBinaryProtocol.TBinaryProtocol( userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) # check EDAM version versionOK = userStore.checkVersion( "Python EDAMTest", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) if not (versionOK): raise Exception("EDAM versions do not match") # unwrap the session variables oauth_token = session['oauth_token'] shard = session['shard'] user_id = session['user'] user = EvernoteUser.get_by_key_name(user_id) notebook_id = user.notebook_id # set up the thrift protocol for noteStore noteStoreUri = NOTESTORE_URI_BASE + shard noteStoreHttpClient = THttpClient.THttpClient(noteStoreUri) noteStoreProtocol = TBinaryProtocol.TBinaryProtocol( noteStoreHttpClient) noteStore = NoteStore.Client(noteStoreProtocol) log = logging.getLogger(__name__) # get or make the notebook pensievr_nb = None if not (notebook_id): # first look for the notebook try: notebooks = noteStore.listNotebooks(oauth_token) except Errors.EDAMUserException, e: # save the note note = EvernoteNote(user=user, note=post, loc_lat=loc_lat, loc_long=loc_long) note.put() # clear out the bad session session.terminate() self.redirect("/") for notebook in notebooks: if notebook.name == NOTEBOOK_NAME: pensievr_nb = notebook # if we don't have a pensievr notebook, make one tmp_nb = Types.Notebook() tmp_nb.name = NOTEBOOK_NAME tmp_nb.defaultNotebook = False tmp_nb.published = False if not (pensievr_nb): try: pensievr_nb = noteStore.createNotebook(oauth_token, tmp_nb) except Errors.EDAMUserException, e: if e.errorCode != 9: # INVALID_AUTH raise # save the note note_obj = EvernoteNote(user=user, note=post, loc_lat=loc_lat, loc_long=loc_long) note_obj.put() # clear out the bad session session.terminate() self.redirect("/")
def get_userstore(): """Return an instance of the Evernote UserStore.""" userStoreHttpClient = THttpClient.THttpClient(EN_USERSTORE_URIBASE) userStoreProtocol = TBinaryProtocol.TBinaryProtocol(userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) return userStore
password = sys.argv[2] # # NOTE: You must change the consumer key and consumer secret to the # key and secret that you received from Evernote # consumerKey = "westine" consumerSecret = "277e8b3a8cc49b2d" evernoteHost = "www.evernote.com" #this is production service userStoreUri = "https://" + evernoteHost + "/edam/user" noteStoreUriBase = "https://" + evernoteHost + "/edam/note/" userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol(userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) versionOK = userStore.checkVersion("Python EDAMTest", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) print "Is my EDAM protocol version up to date? ", str(versionOK) print "" if not versionOK: exit(1) # Authenticate the user try: authResult = userStore.authenticate(username, password, consumerKey, consumerSecret) except Errors.EDAMUserException, e:
def __setUserStore(self): # {{{ """ setup userStore. """ userStoreHttpClient = THttpClient.THttpClient(USERSTORE_URI) userStoreProtocol = TBinaryProtocol.TBinaryProtocol(userStoreHttpClient) self.userStore = UserStore.Client(userStoreProtocol)
def __init__(self): username = settings.EVERNOTE_USER password = settings.EVERNOTE_PW consumerKey = settings.EVERNOTE_CONSUMER_KEY consumerSecret = settings.EVERNOTE_CONSUMER_SECRET evernoteHost = settings.EVERNOTE_HOST userStoreUri = "https://" + evernoteHost + "/edam/user" noteStoreUriBase = "https://" + evernoteHost + "/edam/note/" userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol( userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) versionOK = userStore.checkVersion( "Python EDAMTest", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) if not versionOK: raise Exception("Invalid EDAM Version") # Authenticate the user try: authResult = userStore.authenticate(username, password, consumerKey, consumerSecret) except Errors.EDAMUserException as e: # See http://www.evernote.com/about/developer/api/ref/UserStore.html#Fn_UserStore_authenticate parameter = e.parameter errorCode = e.errorCode errorText = Errors.EDAMErrorCode._VALUES_TO_NAMES[errorCode] print "Authentication failed (parameter: " + parameter + " errorCode: " + errorText + ")" if errorCode == Errors.EDAMErrorCode.INVALID_AUTH: if parameter == "consumerKey": if consumerKey == "en-edamtest": print "You must replace the variables consumerKey and consumerSecret with the values you received from Evernote." else: print "Your consumer key was not accepted by", evernoteHost print "This sample client application requires a client API key. If you requested a web service API key, you must authenticate using OAuth." print "If you do not have an API Key from Evernote, you can request one from http://www.evernote.com/about/developer/api" elif parameter == "username": print "You must authenticate using a username and password from", evernoteHost if evernoteHost != "www.evernote.com": print "Note that your production Evernote account will not work on", evernoteHost print "You must register for a separate test account at https://" + evernoteHost + "/Registration.action" elif parameter == "password": print "The password that you entered is incorrect" print "" exit(1) userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol( userStoreHttpClient) self.userStore = UserStore.Client(userStoreProtocol) versionOK = self.userStore.checkVersion( "Python EDAMTest", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) if not versionOK: print "Old EDAM version" exit(1) authResult = self.userStore.authenticate(username, password, consumerKey, consumerSecret) self.authToken = authResult.authenticationToken noteStoreUri = noteStoreUriBase + authResult.user.shardId noteStoreHttpClient = THttpClient.THttpClient(noteStoreUri) noteStoreProtocol = TBinaryProtocol.TBinaryProtocol( noteStoreHttpClient) self.noteStore = NoteStore.Client(noteStoreProtocol)
def show_entry(page): authToken = '' if authToken == "wrong": print "Please fill in your developer token" print "To get a developer token, visit https://sandbox.evernote.com/api/DeveloperToken.action" exit(1) # https://www.evernote.com/api/DeveloperToken.action evernoteHost = "www.evernote.com" userStoreUri = "https://" + evernoteHost + "/edam/user" userStoreHttpClient = THttpClient.THttpClient(userStoreUri) userStoreProtocol = TBinaryProtocol.TBinaryProtocol(userStoreHttpClient) userStore = UserStore.Client(userStoreProtocol) versionOK = userStore.checkVersion("Evernote EDAMTest (Python)", UserStoreConstants.EDAM_VERSION_MAJOR, UserStoreConstants.EDAM_VERSION_MINOR) if not versionOK: exit(1) noteStoreUrl = userStore.getNoteStoreUrl(authToken) noteStoreHttpClient = THttpClient.THttpClient(noteStoreUrl) noteStoreProtocol = TBinaryProtocol.TBinaryProtocol(noteStoreHttpClient) noteStore = NoteStore.Client(noteStoreProtocol) #get access to default notebook notebooks = noteStore.listNotebooks(authToken) for notebook in notebooks: print notebook.name if notebook.name == "Blog": filter = NoteStore.NoteFilter() filter.notebookGuid = notebook.guid filter.order = Types.NoteSortOrder.UPDATED filter.ascending = False notes = noteStore.findNotes(authToken, filter, 0, 10000) for note in notes.notes: note = noteStore.getNote(authToken, note.guid, withContent=True, withResourcesData=True, withResourcesRecognition=False, withResourcesAlternateData=False) g.db.execute( 'insert or replace into entries (created, title, text) values (?, ?, ?)', [note.created, note.title, note.content.decode('utf-8')]) g.db.commit() #Show all entries cur = g.db.execute( 'select created, title, text from entries order by created desc') entries = [] for row in cur.fetchall(): readable = time.ctime(row[0] / 1000) content = row[2] entry = dict(created=readable, title=row[1], text=row[2]) entries.append(entry) count = len(entries) final_values = page - 1 smaller = page - 1 larger = page + 1 previous = True after = False if final_values == 0: previous = False if final_values + PER_PAGE < count: final_entries = entries[final_values:PER_PAGE] else: final_entries = entries[final_values:count] after = False if not entries and page != 1: abort(404) return render_template('show_entries.html', entries = final_entries, previous = previous, after = after, \ smaller = smaller, larger = larger)
def get_user_store(self): if self.user_store is None: client = THttpClient.THttpClient(USER_STORE_URI) protocol = TBinaryProtocol.TBinaryProtocol(client) self.user_store = UserStore.Client(protocol) return self.user_store