public IEnumerable<EverNote> GetDefaultNoteBookNotes(string authToken)
        {
            var noteStoreUrl = GetNoteStoreUrl(authToken);
            var transport = new THttpClient(new Uri(noteStoreUrl));
            var protocol = new TBinaryProtocol(transport);
            var noteStore = new NoteStore.Client(protocol);
            var notes = new List<EverNote>();

            var notebooks = noteStore.listNotebooks(authToken);

            foreach (Notebook notebook in notebooks)
            {
                if (notebook.DefaultNotebook)
                {
                    var findResult = noteStore.findNotes(authToken, new NoteFilter { NotebookGuid = notebook.Guid }, 0, int.MaxValue);
                    foreach (var note in findResult.Notes)
                    {
                        notes.Add(new EverNote(note.Guid, note.Title));
                    }
                    break;
                }
            }

            return notes;
        }
Example #2
0
 internal static NoteStore.Client GetNoteStoreClient(String edamBaseUrl, User user)
 {
     Uri noteStoreUrl = new Uri(edamBaseUrl + "/edam/note/" + user.ShardId);
     TTransport noteStoreTransport = new THttpClient(noteStoreUrl);
     TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
     NoteStore.Client noteStore = new NoteStore.Client(noteStoreProtocol);
     return noteStore;
 }
Example #3
0
        public EvernoteServiceSDK1(EFDbEvernoteCredentials credentials)
        {
            this.credentials = credentials;

            THttpClient noteStoreTransport = new THttpClient(new Uri(credentials.NotebookUrl));
            TBinaryProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
            noteStore = new NoteStore.Client(noteStoreProtocol);
        }
        public Auth001Test(String authToken, NoteStore.Client noteStore)
        {
            mAuthToken = authToken;
            mNoteStore = noteStore;

            mConsumerKey = Properties.Settings.Default.ConsumerKey;
            mConsumerSecret = Properties.Settings.Default.ConsumerSecret;
            mEvernoteHost = Properties.Settings.Default.EvernoteHost;
            mUserName = Properties.Settings.Default.UserName;
            mPassword = Properties.Settings.Default.Password;
        }
        public void Run()
        {
            // 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
            //String authToken = "your developer token";
            String authToken = Properties.Settings.Default.AuthToken;

            if (authToken == "your developer token")
            {
                Console.WriteLine("Please fill in your developer token");
                Console.WriteLine("To get a developer token, visit https://sandbox.evernote.com/api/DeveloperToken.action");
                throw new ApplicationException();
            }

            // 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
            String evernoteHost = "sandbox.evernote.com";

            Uri userStoreUrl = new Uri("https://" + evernoteHost + "/edam/user");
            TTransport userStoreTransport = new THttpClient(userStoreUrl);
            TProtocol userStoreProtocol = new TBinaryProtocol(userStoreTransport);
            UserStore.Client userStore = new UserStore.Client(userStoreProtocol);

            bool versionOK =
                userStore.checkVersion("Evernote EDAMTest (C#)",
                   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MAJOR,
                   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MINOR);
            Console.WriteLine("Is my Evernote API version up to date? " + versionOK);
            if (!versionOK)
            {
                return;
            }

            // 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.
            String noteStoreUrl = userStore.getNoteStoreUrl(authToken);

            TTransport noteStoreTransport = new THttpClient(new Uri(noteStoreUrl));
            TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
            NoteStore.Client noteStore = new NoteStore.Client(noteStoreProtocol);

            mAuthToken = authToken;
            mNoteStore = noteStore;
        }
Example #6
0
        /// <summary>
        /// Fetches the first n suitable notes to tweet.
        /// </summary>
        public static List<Note> GetNotesToTweet( int numNotesWanted )
        {
            if ( LoginNeeded )
                Login( );

            // Connect to the note store.  
            log.Info( "Fetching notebooks..." );
            NoteStore.Client noteClient = new NoteStore.Client( new TBinaryProtocol( new THttpClient( new Uri( BaseUrl + "/edam/note/" + authentication.User.ShardId ) ) ) );

            // Find the specified notebook.
            List<Notebook> notebooks = noteClient.listNotebooks( authentication.AuthenticationToken );
            Notebook notebook = notebooks.Find( delegate( Notebook n ) { return n.Name == "Users in Hell"; } );

            // Get a list of the most recent notes.
            NoteList notes = noteClient.findNotes( authentication.AuthenticationToken, new NoteFilter { Ascending = true, Order = 1, NotebookGuid = notebook.Guid }, 0, 300 );
            log.Info( "Found " + notes.Notes.Count + " notes in the notebook." );
            
            // Filter down to the first n untweeted notes. Download the attached images. And return!
            return FetchResources( FilterNotes( notes.Notes, numNotesWanted), noteClient );
        }
        public string GetNoteContent(string authToken, string noteId)
        {
            var noteStoreUrl = GetNoteStoreUrl(authToken);
            var transport = new THttpClient(new Uri(noteStoreUrl));
            var protocol = new TBinaryProtocol(transport);
            var noteStore = new NoteStore.Client(protocol);

            var note = noteStore.getNote(authToken, noteId, false, false, false, false);
            var body = noteStore.getNoteSearchText(authToken, noteId, false, false);

            if (!string.IsNullOrEmpty(body))
            {
                var index = body.LastIndexOf(note.Title);
                if (index > 0)
                {
                    body = body.Substring(0, index);
                }
                body = body.Trim();
            }

            return body;
        }
Example #8
0
    public static void Main(string[] args)
    {
        // Developer token for Evernote API
        String authToken = "S=s1:U=2261f:E=13eccfa5d71:C=13775493171:P=1cd:A=en-devtoken:H=fe7ee8dac619c7d380a0f9f3731a8698";

        String evernoteHost = "sandbox.evernote.com";

        Uri userStoreUrl = new Uri("https://" + evernoteHost + "/edam/user");
        TTransport userStoreTransport = new THttpClient(userStoreUrl);
        TProtocol userStoreProtocol = new TBinaryProtocol(userStoreTransport);
        UserStore.Client userStore = new UserStore.Client(userStoreProtocol);

        FNHSessionManager<NoteEntry> sessionManager = new FNHSessionManager<NoteEntry>(FNHSessionManager<NoteEntry>.DatabaseType.MySQL);
        FNHRepository<NoteEntry> repository = new FNHRepository<NoteEntry>(sessionManager);

        bool versionOK =
            userStore.checkVersion("Evernote EDAMTest (C#)",
               Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MAJOR,
               Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MINOR);
        Console.WriteLine("Is my Evernote API version up to date? " + versionOK);
        if (!versionOK) {
            return;
        }

        // 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.
        String noteStoreUrl = userStore.getNoteStoreUrl(authToken);

        TTransport noteStoreTransport = new THttpClient(new Uri(noteStoreUrl));
        TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
        NoteStore.Client noteStore = new NoteStore.Client(noteStoreProtocol);

        // Lists all of the notebooks in the user's account with a notebook count
        List<Notebook> notebooks = noteStore.listNotebooks(authToken);
        Console.WriteLine("Found " + notebooks.Count + " notebooks:");
        foreach (Notebook notebook in notebooks) {
            Console.WriteLine("  * " + notebook.Name);
        }

        //The offset represents the index of the first note that is to be returned
        int offset = 0;

        //maxNotes represents the number of note that is to be returned
        int maxNotes = 15;

        //NoteFilter is a struct that contains a list of criteria you can search notes for.
        //In this app, NoteFilter.Words will be used to return notes containing a certain string.
        NoteFilter filter = new NoteFilter();

        Console.WriteLine();
        Console.WriteLine("What word do you want to search through the notes for?");
        Console.WriteLine("Enter word: ");
        filter.Words = Console.ReadLine();
        //filter.Words = "business";

        //Creates a new NoteList struct, which returns a list of individual notes out of a larger set of them
        NoteList noteList = new NoteList();

        //This finds all notes containing the word that was given by the user
        noteList = noteStore.findNotes(authToken, filter, offset, maxNotes);

        //This stores the Guids of the notes containing the word
        ArrayList guidList = new ArrayList();

        // For each note in the list of notes...
        foreach (Note fetchedNote in noteList.Notes)
        {
            //Console.WriteLine("  * " + fetchedNote.Guid);

            // Add guid to list
            guidList.Add(fetchedNote.Guid);
        }

        // For each guid in the list...
        foreach (String Guid in guidList)
        {
            // Get the contents of the matching notes
            String text = noteStore.getNoteContent(authToken, Guid);

            // Then split the contents by line
            string[] split = Regex.Split(text, "\\n");

            Console.WriteLine();

            int MAX = split.Length;

            String line1;
            String line2;
            String line3;

            // This for-loop cycles through each line in the array of lines and tests if the line contains the word.
            // If so, it sets the note Guid as well as the surrounding lines as properties to a new Entry object.

            for (int n = 0; n < MAX; n++)
            {
                Boolean b = split[n].Contains(filter.Words);

                if (b == true)
                {
                    line2 = split[n];
                    line1 = split[n - 1];
                    line3 = split[n + 1];

                    Entry postgresEntry = new Entry();
                    postgresEntry.setGuid(Guid);
                    postgresEntry.setLine1(line1);
                    postgresEntry.setLine2(line2);
                    postgresEntry.setLine3(line3);

                    Console.WriteLine("Note GUID: " + postgresEntry.getGuid());
                    Console.WriteLine();
                    postgresEntry.displayLines();
                    postgresEntry.InsertRow();
                    Console.WriteLine();
                    //postgresEntry.getLastInsertedRow();

                    NoteEntry mysqlNote = new NoteEntry();
                    mysqlNote.Guid = Guid;
                    mysqlNote.Line1 = line1;
                    mysqlNote.Line2 = line2;
                    mysqlNote.Line3 = line3;

                    repository.Create(mysqlNote);
                }
            }
        }

        Console.WriteLine();
        Console.WriteLine("These lines have been saved to a Postgresql database using ODBC.");
        Console.WriteLine("They have also been saved to a MySQL database using Fluent NHibernate.");
        Console.WriteLine();
        Console.WriteLine("Which row do you want to retrieve from the MySQL database?");
        String id = Console.ReadLine();
        int num = int.Parse(id);
        NoteEntry noteEntry = repository.RetrieveById(num);

        Console.WriteLine("This is entry " + num + " retrieved from the MySQL database...");
        Console.WriteLine();
        Console.WriteLine("GUID: " + noteEntry.Guid);
        Console.WriteLine("Line 1: " + noteEntry.Line1);
        Console.WriteLine("Line 2: " + noteEntry.Line2);
        Console.WriteLine("Line 3: " + noteEntry.Line3);
        Console.WriteLine();

        Console.WriteLine("Click ENTER to continue...");
        Console.ReadLine();
    }
 public Note001Test(String authToken, NoteStore.Client noteStore)
 {
     mAuthToken = authToken;
     mNoteStore = noteStore;
 }
Example #10
0
        public static void RunImpl(object state)
        {
            // Username and password of the Evernote user account to access
            const string username = ""; // Enter your username here
            const string password = ""; // Enter your password here

            if ((ConsumerKey == String.Empty) || (ConsumerSecret == String.Empty))
            {
                ShowMessage("Please provide your API key in Sample.cs");
                return;
            }
            if ((username == String.Empty) || (password == String.Empty))
            {
                ShowMessage("Please provide your username and password in Sample.cs");
                return;
            }

            // Instantiate the libraries to connect the service
            TTransport userStoreTransport = new THttpClient(new Uri(UserStoreUrl));
            TProtocol userStoreProtocol = new TBinaryProtocol(userStoreTransport);
            UserStore.Client userStore = new UserStore.Client(userStoreProtocol);

            // Check that the version is correct
            bool versionOK =
                userStore.checkVersion("C# EDAMTest",
                   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MAJOR,
                   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MINOR);
            InvokeOnUIThread(() => ViewModel.TheViewModel.VersionOK = versionOK);
            Debug.WriteLine("Is my EDAM protocol version up to date? " + versionOK);
            if (!versionOK)
            {
                return;
            }

            // Now we are going to authenticate
            AuthenticationResult authResult;
            try
            {
                authResult = userStore.authenticate(username, password, ConsumerKey, ConsumerSecret);
            }
            catch (EDAMUserException ex)
            {
                HandleAuthenticateException(EvernoteHost, ConsumerKey, ex);
                return;
            }
            Debug.WriteLine("We are connected to the service");

            // User object received after authentication
            User user = authResult.User;
            String authToken = authResult.AuthenticationToken;
            InvokeOnUIThread(() => ViewModel.TheViewModel.AuthToken = authToken);

            Debug.WriteLine("Authentication successful for: " + user.Username);
            Debug.WriteLine("Authentication token = " + authToken);

            // Creating the URL of the NoteStore based on the user object received
            String noteStoreUrl = EDAMBaseUrl + "/edam/note/" + user.ShardId;

            TTransport noteStoreTransport = new THttpClient(new Uri(noteStoreUrl));
            TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
            NoteStore.Client noteStore = new NoteStore.Client(noteStoreProtocol);

            // Listing all the user's notebook
            List<Notebook> notebooks = noteStore.listNotebooks(authToken);
            Debug.WriteLine("Found " + notebooks.Count + " notebooks:");
            InvokeOnUIThread(() => notebooks.ForEach(notebook => ViewModel.TheViewModel.Notebooks.Add(notebook)));

            // Find the default notebook
            Notebook defaultNotebook = notebooks.Single(notebook => notebook.DefaultNotebook);

            // Printing the names of the notebooks
            foreach (Notebook notebook in notebooks)
            {
                Debug.WriteLine("  * " + notebook.Name);
            }

            // Listing the first 10 notes in the default notebook
            NoteFilter filter = new NoteFilter { NotebookGuid = defaultNotebook.Guid };
            NoteList notes = noteStore.findNotes(authToken, filter, 0, 10);
            InvokeOnUIThread(() => notes.Notes.ForEach(note => ViewModel.TheViewModel.Notes.Add(note)));
            foreach (Note note in notes.Notes)
            {
                Debug.WriteLine("  * " + note.Title);
            }

            // Creating a new note in the default notebook
            Debug.WriteLine("Creating a note in the default notebook: " + defaultNotebook.Name);

            Note newNote = new Note
                            {
                                NotebookGuid = defaultNotebook.Guid,
                                Title = "Test note from EDAMTest.cs",
                                Content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                                          "<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">" +
                                          "<en-note>Here's an Evernote test note<br/>" +
                                          "</en-note>"
                            };

            Note createdNote = noteStore.createNote(authToken, newNote);

            ShowMessage("Successfully created new note with GUID: " + createdNote.Guid);
        }
Example #11
0
        /// <summary>
        /// Create a new note in the account of the user with the specified developer token.
        /// </summary>
        /// <returns>true if the note was created successfully, false otherwise.</returns>
        public bool createNote(String developerToken)
        {
            try
            {
                try
                {
                    if (!auth(developerToken))
                    {
                        // This is an unrecoverable error - our protocol version is out of date
                        return false;
                    }
                }
                catch (EDAMUserException eux)
                {
                    // TODO - do proper error handling
                    return false;
                }

                THttpClient noteStoreTransport = new THttpClient(new Uri(noteStoreUrl));
                noteStoreTransport.CustomHeaders[HttpRequestHeader.UserAgent.ToString()] = USER_AGENT;
                TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
                NoteStore.Client noteStore = new NoteStore.Client(noteStoreProtocol);

                // The bytes of the image we want to send up to the service
                // In this test, we use an image hardcoded as a base64-encoded string
                IBuffer imageBuffer = CryptographicBuffer.DecodeFromBase64String(imgBase64);
                byte[] imageBytes = WindowsRuntimeBufferExtensions.ToArray(imageBuffer);
                
                HashAlgorithmProvider provider = HashAlgorithmProvider.OpenAlgorithm("MD5");
                IBuffer hashBuffer = provider.HashData(imageBuffer);
                byte[] hash = WindowsRuntimeBufferExtensions.ToArray(hashBuffer);
                String hashHex = CryptographicBuffer.EncodeToHexString(hashBuffer);

                Data data = new Data();
                data.Size = imageBytes.Length;
                data.BodyHash = hash;
                data.Body = imageBytes;

                Resource resource = new Resource();
                resource.Mime = "image/png";
                resource.Data = data;

                Note note = new Note();
                note.Title = "Hello, World!";
                note.Content = EDAM_NOTE_PREAMBLE + 
                    "<h2>This note is created by the Evernote sample code for Windows Store applications!</h2>" + 
                    "<br />" +
                    "<en-media type=\"image/png\" hash=\"" + hashHex + "\"/>" +
                    EDAM_NOTE_POSTAMBLE;
                note.Resources = new List<Resource>();
                note.Resources.Add(resource);

                try
                {
                    noteStore.createNote(authToken, note);
                    return true;
                }
                catch (EDAMUserException ex)
                {
                    // Handle note creation failure
                }
            }
            catch (TApplicationException tax)
            {
                // Handle generic Thrift error
            }
            catch (TTransportException ttx)
            {
                // Handle networking error
            }
            catch (EDAMSystemException esx)
            {
                // Handle unrecoverable Evernote error (i.e., error not caused by bad user input)
            }

            return false;
        }
Example #12
0
    public static void Main(string[] args) {

        // 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
        String authToken = "your developer token";

        if (authToken == "your developer token") {
          Console.WriteLine("Please fill in your developer token");
          Console.WriteLine("To get a developer token, visit https://sandbox.evernote.com/api/DeveloperToken.action");
          Console.ReadLine();
          return;
        }


        // 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
        String evernoteHost = "sandbox.evernote.com";
                
        Uri userStoreUrl              = new Uri("https://" + evernoteHost + "/edam/user");
        TTransport userStoreTransport = new THttpClient(userStoreUrl);
        TProtocol userStoreProtocol   = new TBinaryProtocol(userStoreTransport);
        UserStore.Client userStore    = new UserStore.Client(userStoreProtocol);
        
        bool versionOK =
            userStore.checkVersion("Evernote EDAMTest (C#)",
        	   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MAJOR,
        	   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MINOR);
        Console.WriteLine("Is my Evernote API version up to date? " + versionOK);
        if (!versionOK) {
            return;
        }

        // 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.
        String noteStoreUrl = userStore.getNoteStoreUrl(authToken);

        TTransport noteStoreTransport = new THttpClient(new Uri(noteStoreUrl));
        TProtocol noteStoreProtocol   = new TBinaryProtocol(noteStoreTransport);
        NoteStore.Client noteStore    = new NoteStore.Client(noteStoreProtocol);

        // List all of the notebooks in the user's account        
        List<Notebook> notebooks = noteStore.listNotebooks(authToken);
        Console.WriteLine("Found " + notebooks.Count + " notebooks:");
        foreach (Notebook notebook in notebooks) {
            Console.WriteLine("  * " + notebook.Name);
        }

        // Sample Code To Add A Notebook
        //Notebook newNoteBook = new Notebook();
        //newNoteBook.Name     = "Test Notebook";
        //noteStore.createNotebook(authToken, newNoteBook); 

        Console.WriteLine();
        Console.WriteLine("Creating a note in the default notebook");
        Console.WriteLine();
                
        // To create a new note, simply create a new Note object and fill in 
        // attributes such as the note's title.
        Note note  = new Note();
        note.Title = "Evernote Logo";

        // To include an attachment such as an image in a note, first create a Resource
        // for the attachment. At a minimum, the Resource contains the binary attachment 
        // data, an MD5 hash of the binary data, and the attachment MIME type. It can also 
        // include attributes such as filename and location.
        ImageConverter converter = new ImageConverter();
        byte[] image = (byte[])converter.ConvertTo(Resources.enlogo, typeof(byte[]));
        byte[] hash = new MD5CryptoServiceProvider().ComputeHash(image);
        
        Data data     = new Data();
        data.Size     = image.Length;
        data.BodyHash = hash;
        data.Body     = image;
        
        Resource resource = new Resource();
        resource.Mime     = "image/png";
        resource.Data     = data;

        // Now, add the new Resource to the note's list of resources
        note.Resources = new List<Resource>();
        note.Resources.Add(resource);

        // To display the Resource as part of the note's content, include an <en-media>
        // tag in the note's ENML content. The en-media tag identifies the corresponding
        // Resource using the MD5 hash.
        string hashHex = BitConverter.ToString(hash).Replace("-", "").ToLower();

        // The content of an Evernote note is represented using Evernote Markup Language
        // (ENML). The full ENML specification can be found in the Evernote API Overview
        // at http://dev.evernote.com/documentation/cloud/chapters/ENML.php
        note.Content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
            "<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">" +
            "<en-note>Here's the Evernote logo:<br/>" +
            "<en-media type=\"image/png\" hash=\"" + hashHex + "\"/>" +
            "</en-note>";

        // Finally, send the new note to Evernote using the createNote method
        // The new Note object that is returned will contain server-generated
        // attributes such as the new note's unique GUID.
        Note createdNote = noteStore.createNote(authToken, note);

        Console.WriteLine();
        Console.WriteLine("Successfully created new note with GUID: " + createdNote.Guid);
        Console.WriteLine();
 
        // Share The Newly Created Note To Provide Access Using An Evernote URL
        // This Document Will Be Publicly Accessible.  
        string noteKey = noteStore.shareNote(authToken, createdNote.Guid);

        Console.WriteLine();
        Console.WriteLine("Successfully shared new note with Note Key: " + noteKey);
        Console.WriteLine();

        // Twitter Integration
        try
        {

            // You Can Find Your SharedId By Sharing A Document On Your Evernote Sandbox Account
            // The Evernote Generated URL Will Contain This Value
            string sharedId = "s1";
            string noteLink = "https://sandbox.evernote.com/shard/" + sharedId + "/sh/" + createdNote.Guid + "/" + noteKey;

            // You Will Need To Create A Twitter Developer Account For This Information.
            // All Of The Values Below Will Be Generated From Your Twitter Developer Account
            // Login In To Twitter And Use The Following URL:  https://dev.twitter.com/apps
            //   1. Create Twitter Developer Account
            //   2. Create A New Application
            //   2. Set Access Level To Read and Write On The Application Page
            //   3. Generate Access Token At Bottom Of The Application Page
            OAuthTokens oaTokens       = new OAuthTokens();
            oaTokens.AccessToken       = "Your Twitter Access Token Here";
            oaTokens.AccessTokenSecret = "Your Twitter Access Token Secret Here";
            oaTokens.ConsumerKey       = "Your Twitter ConsumerKey Here";
            oaTokens.ConsumerSecret    = "Your Twitter ConsumerKey Here";

            // Truncate Doc Title If It Is Longer Than 40 Characters
            string docTitle = createdNote.Title;
            if (docTitle.Length > 40)
            {
                docTitle.Substring(0, 40);
            }

            // Truncate Message If It Is Longer Than 140 Characters
            string message = "Evernote Doc - " + docTitle;
            if (message.Length > 140)
            {
                message = message.Substring(0, 140);
            }
            // Add URL To Tweet.  Twitter Will Shorten If Neccessary
            message += " " + noteLink;

            // Update Twitter Status And Check Result For Success
            TwitterResponse<TwitterStatus> twStatus = TwitterStatus.Update(oaTokens, message); 
            if (twStatus.Result.ToString().ToLower() != "success")
            {
                throw new Exception("Twitter Status Not Updated");
            }

            Console.WriteLine();
            Console.Write("Document Posted To Twitter");
            Console.WriteLine();

        }
        catch (Exception ex)
        {
            Console.Write(ex.ToString());
        }

        Console.ReadLine();
    }
Example #13
0
        /// <summary>
        /// Create a new note in the account of the user with the specified Evernote username and password.
        /// </summary>
        /// <returns>true if the note was created successfully, false otherwise.</returns>
        public bool createNote(String username, String password)
        {
            try
            {
                try
                {
                    if (!auth(username, password))
                    {
                        // This is an unrecoverable error - our protocol version is out of date
                        return false;
                    }
                }
                catch (EDAMUserException eux)
                {
                    // I'm showing some of the most common error codes here that we might want to handle separately.
                    // For the full list, see 
                    // http://dev.evernote.com/documentation/reference/UserStore.html#Fn_UserStore_authenticate
                    if (eux.ErrorCode == EDAMErrorCode.INVALID_AUTH)
                    {
                        if (eux.Parameter == "username" || eux.Parameter == "password")
                        {
                            // We failed to authenticate because the username or password was invalid
                            // This is a recoverable error that the user can fix
                        }
                        else
                        {
                            // Our API key was invalid, or something else wonky happened
                            // The user can't help us recover from this
                        }
                    }
                    else if (eux.ErrorCode == EDAMErrorCode.PERMISSION_DENIED)
                    {
                        if (eux.Parameter == "User.active")
                        {
                            // The credentials were correct, but this user account is not active
                        }
                    }
                    else
                    {
                        // We failed to authenticate for some other reason
                    }
                    return false;
                }

                THttpClient noteStoreTransport = new THttpClient(new Uri(noteStoreUrl));
                noteStoreTransport.CustomHeaders[HttpRequestHeader.UserAgent.ToString()] = USER_AGENT;
                TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
                NoteStore.Client noteStore = new NoteStore.Client(noteStoreProtocol);

                // The bytes of the image we want to send up to the service
                // In this test, we use an image hardcoded as a base64-encoded string
                IBuffer imageBuffer = CryptographicBuffer.DecodeFromBase64String(imgBase64);
                byte[] imageBytes = WindowsRuntimeBufferExtensions.ToArray(imageBuffer);
                
                HashAlgorithmProvider provider = HashAlgorithmProvider.OpenAlgorithm("MD5");
                IBuffer hashBuffer = provider.HashData(imageBuffer);
                byte[] hash = WindowsRuntimeBufferExtensions.ToArray(hashBuffer);
                String hashHex = CryptographicBuffer.EncodeToHexString(hashBuffer);

                Data data = new Data();
                data.Size = imageBytes.Length;
                data.BodyHash = hash;
                data.Body = imageBytes;

                Resource resource = new Resource();
                resource.Mime = "image/png";
                resource.Data = data;

                Note note = new Note();
                note.Title = "Hello, World!";
                note.Content = EDAM_NOTE_PREAMBLE + 
                    "<h2>This note is created by Skitch for Metro!</h2>" + 
                    "<br />" +
                    "<en-media type=\"image/png\" hash=\"" + hashHex + "\"/>" +
                    EDAM_NOTE_POSTAMBLE;
                note.Resources = new List<Resource>();
                note.Resources.Add(resource);

                try
                {
                    noteStore.createNote(authToken, note);
                    return true;
                }
                catch (EDAMUserException ex)
                {
                    // Handle note creation failure
                }
            }
            catch (TApplicationException tax)
            {
                // Handle generic Thrift error
            }
            catch (TTransportException ttx)
            {
                // Handle networking error
            }
            catch (EDAMSystemException esx)
            {
                // Handle unrecoverable Evernote error (i.e., error not caused by bad user input)
            }

            return false;
        }
Example #14
0
        public static void RunImpl(object state)
        {
            if (authToken == "your developer token") {
            {
                ShowMessage("Please fill in your devleoper token in Sample.cs");
                return;
            }

            // Instantiate the libraries to connect the service
            TTransport userStoreTransport = new THttpClient(new Uri(UserStoreUrl));
            TProtocol userStoreProtocol = new TBinaryProtocol(userStoreTransport);
            UserStore.Client userStore = new UserStore.Client(userStoreProtocol);

            // Check that the version is correct
            bool versionOK =
                userStore.checkVersion("Evernote EDAMTest (WP7)",
                   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MAJOR,
                   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MINOR);
            InvokeOnUIThread(() => ViewModel.TheViewModel.VersionOK = versionOK);
            Debug.WriteLine("Is my Evernote API version up to date? " + versionOK);
            if (!versionOK)
            {
                return;
            }

            // 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.
            String noteStoreUrl = userStore.getNoteStoreUrl(authToken);

            TTransport noteStoreTransport = new THttpClient(new Uri(authResult.NoteStoreUrl));
            TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
            NoteStore.Client noteStore = new NoteStore.Client(noteStoreProtocol);

            // Listing all the user's notebook
            List<Notebook> notebooks = noteStore.listNotebooks(authToken);
            Debug.WriteLine("Found " + notebooks.Count + " notebooks:");
            InvokeOnUIThread(() => notebooks.ForEach(notebook => ViewModel.TheViewModel.Notebooks.Add(notebook)));

            // Find the default notebook
            Notebook defaultNotebook = notebooks.Single(notebook => notebook.DefaultNotebook);

            // Printing the names of the notebooks
            foreach (Notebook notebook in notebooks)
            {
                Debug.WriteLine("  * " + notebook.Name);
            }

            // Listing the first 10 notes in the default notebook
            NoteFilter filter = new NoteFilter { NotebookGuid = defaultNotebook.Guid };
            NoteList notes = noteStore.findNotes(authToken, filter, 0, 10);
            InvokeOnUIThread(() => notes.Notes.ForEach(note => ViewModel.TheViewModel.Notes.Add(note)));
            foreach (Note note in notes.Notes)
            {
                Debug.WriteLine("  * " + note.Title);
            }

            // Creating a new note in the default notebook
            Debug.WriteLine("Creating a note in the default notebook: " + defaultNotebook.Name);

            Note newNote = new Note
                            {
                                NotebookGuid = defaultNotebook.Guid,
                                Title = "Test note from EDAMTest.cs",
                                Content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                                          "<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">" +
                                          "<en-note>Here's an Evernote test note<br/>" +
                                          "</en-note>"
                            };

            Note createdNote = noteStore.createNote(authToken, newNote);

            ShowMessage("Successfully created new note with GUID: " + createdNote.Guid);
        }
        public bool BeginSyncTransaction()
        {
            Logger.Debug("[Evernote] Begining Sync...");
            if (ConsumerKey.Equals("your_key_here"))
            {
                throw new Exception("You need to Update the Evernote ConsumerKey!! Open up the EvernoteSyncServer.cs file and look at it!");
            }
            ServicePointManager.CertificatePolicy = new CertificateManager ();
            //ServicePointManager.ServerCertificateValidationCallback += ValidateServerCertificate;
            bool versionOK =
                _userStore.checkVersion("Tomboy.EvernoteSyncAddin",
                                        Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MAJOR,
                                        Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MINOR);

            if (!versionOK)
            {
                Logger.Error("[Evernote] EDAM protocol version not up to date: " +
                             Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MAJOR + "." +
                             Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MINOR);
                return false;
            }
            string username;
            string password;
            if (!EvernoteSyncServiceAddin.GetConfigSettings(out username, out password))
            {
                return false;
            }
            AuthenticationResult authResult =
                _userStore.authenticate(username, password, ConsumerKey, ConsumerSecret);
            User user = authResult.User;
            _authToken = authResult.AuthenticationToken;
            Logger.Debug("[Evernote] Authentication successful for: " + user.Username);
            Logger.Debug("[Evernote] Authentication token = " + _authToken);

            String noteStoreUrl = EdamBaseUrl + "/edam/note/" + user.ShardId;
            TTransport noteStoreTransport = new THttpClient(noteStoreUrl);
            TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
            _noteStore = new NoteStore.Client(noteStoreProtocol);

            //TODO - check if the user has a 'Tomboy' Notebook. If not, add one
            bool foundTomboyNotebook = false;
            List<Notebook> notebooks = _noteStore.listNotebooks(_authToken);
            foreach (Notebook notebook in notebooks)
            {
                if (notebook.Name.ToLowerInvariant().Trim().Equals("tomboy"))
                {
                    foundTomboyNotebook = true;
                    _tomboyNotebook = notebook;
                }
            }

            if (!foundTomboyNotebook)
            {
                // no tomboy notebook found, so try to add one
                _tomboyNotebook = new Notebook();
                _tomboyNotebook.Name = "Tomboy";
                _tomboyNotebook.DefaultNotebook = false;
                _tomboyNotebook.Guid = new Guid().ToString();
                _tomboyNotebook = _noteStore.createNotebook(_authToken, _tomboyNotebook);
                if (_tomboyNotebook == null)
                {
                    Logger.Error("[Evernote] Could not create 'Tomboy' notebook in evernote");
                    return false;
                }
                Console.WriteLine("[Evernote] New Tomboy notebook with guid : " + _tomboyNotebook.Guid);
            }

            return true;
        }
    public static void Main(string[] args) {

        // --------------------------------------------------
        // UserStoreオブジェクト作成
        // --------------------------------------------------

        // 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
        String authToken = "your developer token";

        if (authToken == "your developer token") {
          Console.WriteLine("Please fill in your developer token");
          Console.WriteLine("To get a developer token, visit https://sandbox.evernote.com/api/DeveloperToken.action");
          return;
        }

        // 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
        String evernoteHost = "sandbox.evernote.com";
                
        Uri userStoreUrl = new Uri("https://" + evernoteHost + "/edam/user");
        TTransport userStoreTransport = new THttpClient(userStoreUrl);
        TProtocol userStoreProtocol = new TBinaryProtocol(userStoreTransport);
        UserStore.Client userStore = new UserStore.Client(userStoreProtocol);

        // --------------------------------------------------
        // バージョンチェック
        // --------------------------------------------------

        bool versionOK =
            userStore.checkVersion("Evernote EDAMTest (C#)",
        	   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MAJOR,
        	   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MINOR);
        Console.WriteLine("Is my Evernote API version up to date? " + versionOK);
        if (!versionOK) {
            return;
        }

        // --------------------------------------------------
        // NoteStoreオブジェクト作成
        // --------------------------------------------------

        // 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.
        String noteStoreUrl = userStore.getNoteStoreUrl(authToken);

        TTransport noteStoreTransport = new THttpClient(new Uri(noteStoreUrl));
        TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
        NoteStore.Client noteStore = new NoteStore.Client(noteStoreProtocol);

        // --------------------------------------------------
        // ノートブック情報取得
        // --------------------------------------------------

        // List all of the notebooks in the user's account        
        List<Notebook> notebooks = noteStore.listNotebooks(authToken);
        Console.WriteLine("Found " + notebooks.Count + " notebooks:");
        foreach (Notebook notebook in notebooks) {
            Console.WriteLine("  * " + notebook.Name);
        }

        // --------------------------------------------------
        // ノート作成(添付ファイルあり)
        // --------------------------------------------------

        Console.WriteLine();
        Console.WriteLine("Creating a note in the default notebook");
        Console.WriteLine();
                
        // To create a new note, simply create a new Note object and fill in 
        // attributes such as the note's title.
        Note note = new Note();
        note.Title = "Test note from EDAMTest.cs";

        // To include an attachment such as an image in a note, first create a Resource
        // for the attachment. At a minimum, the Resource contains the binary attachment 
        // data, an MD5 hash of the binary data, and the attachment MIME type. It can also 
        // include attributes such as filename and location.
        ImageConverter converter = new ImageConverter();
        byte[] image = (byte[])converter.ConvertTo(Resources.enlogo, typeof(byte[]));
        byte[] hash = new MD5CryptoServiceProvider().ComputeHash(image);
        
        Data data = new Data();
        data.Size = image.Length;
        data.BodyHash = hash;
        data.Body = image;
        
        Resource resource = new Resource();
        resource.Mime = "image/png";
        resource.Data = data;

        // Now, add the new Resource to the note's list of resources
        note.Resources = new List<Resource>();
        note.Resources.Add(resource);

        // To display the Resource as part of the note's content, include an <en-media>
        // tag in the note's ENML content. The en-media tag identifies the corresponding
        // Resource using the MD5 hash.
        string hashHex = BitConverter.ToString(hash).Replace("-", "").ToLower();

        // The content of an Evernote note is represented using Evernote Markup Language
        // (ENML). The full ENML specification can be found in the Evernote API Overview
        // at http://dev.evernote.com/documentation/cloud/chapters/ENML.php
        note.Content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
            "<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">" +
            "<en-note>Here's the Evernote logo:<br/>" +
            "<en-media type=\"image/png\" hash=\"" + hashHex + "\"/>" +
            "</en-note>";

        // Finally, send the new note to Evernote using the createNote method
        // The new Note object that is returned will contain server-generated
        // attributes such as the new note's unique GUID.
        Note createdNote = noteStore.createNote(authToken, note);
        
        Console.WriteLine("Successfully created new note with GUID: " + createdNote.Guid);
    }
Example #17
0
    public static void Main(string[] args) {

        if (args.Length < 2) {
            Console.WriteLine("Arguments:  <username> <password>");
            return;
        }
        String username = args[0];
        String password = args[1];

        // NOTE: You must change the consumer key and consumer secret to the 
        //       key and secret that you received from Evernote
        String consumerKey = "en-edamtest";
        String consumerSecret = "0123456789abcdef";
        
        String evernoteHost = "sandbox.evernote.com";
        String edamBaseUrl = "https://" + evernoteHost;
        // If using Mono, see http://www.mono-project.com/FAQ:_Security
        
        String userStoreUrl = edamBaseUrl + "/edam/user";
        TTransport userStoreTransport = new THttpClient(userStoreUrl);
        TProtocol userStoreProtocol = new TBinaryProtocol(userStoreTransport);
        UserStore.Client userStore = new UserStore.Client(userStoreProtocol);
        
        bool versionOK =
            userStore.checkVersion("C# EDAMTest",
        	   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MAJOR,
        	   Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MINOR);
        Console.WriteLine("Is my EDAM protocol version up to date? " + versionOK);
        if (!versionOK) {
            return;
        }
        
        AuthenticationResult authResult = null;
        try {
            authResult = userStore.authenticate(username, password,
                                                consumerKey, consumerSecret);
        } catch (EDAMUserException ex) {
            String parameter = ex.Parameter;
            EDAMErrorCode errorCode = ex.ErrorCode;
            
            Console.WriteLine("Authentication failed (parameter: " + parameter + " errorCode: " + errorCode + ")");
            
            if (errorCode == EDAMErrorCode.INVALID_AUTH) {
                if (parameter == "consumerKey") {
                    if (consumerKey == "en-edamtest") {
                        Console.WriteLine("You must replace the variables consumerKey and consumerSecret with the values you received from Evernote.");
                    } else {
                        Console.WriteLine("Your consumer key was not accepted by " + evernoteHost);
                        Console.WriteLine("This sample client application requires a client API key. If you requested a web service API key, you must authenticate using OAuth");
                    }
                    Console.WriteLine("If you do not have an API Key from Evernote, you can request one from http://www.evernote.com/about/developer/api");
                } else if (parameter == "username") {
                    Console.WriteLine("You must authenticate using a username and password from " + evernoteHost);
                    if (evernoteHost == "www.evernote.com" == false) {
                        Console.WriteLine("Note that your production Evernote account will not work on " + evernoteHost + ",");
                        Console.WriteLine("you must register for a separate test account at https://" + evernoteHost + "/Registration.action");
                    }
                } else if (parameter == "password") {
                    Console.WriteLine("The password that you entered is incorrect");
                }
            }
            
            return;
        }
        
        User user = authResult.User;
        String authToken = authResult.AuthenticationToken;
        Console.WriteLine("Authentication successful for: " + user.Username);
        Console.WriteLine("Authentication token = " + authToken);
        
        String noteStoreUrl = edamBaseUrl + "/edam/note/" + user.ShardId;
        TTransport noteStoreTransport = new THttpClient(noteStoreUrl);
        TProtocol noteStoreProtocol = new TBinaryProtocol(noteStoreTransport);
        NoteStore.Client noteStore = new NoteStore.Client(noteStoreProtocol);
        
        List<Notebook> notebooks = noteStore.listNotebooks(authToken);
        Console.WriteLine("Found " + notebooks.Count + " notebooks:");
        Notebook defaultNotebook = notebooks[0];
        foreach (Notebook notebook in notebooks) {
            Console.WriteLine("  * " + notebook.Name);
            if (notebook.DefaultNotebook) {
                defaultNotebook = notebook;
            }
        }
        
        Console.WriteLine();
        Console.WriteLine("Creating a note in the default notebook: " +
                          defaultNotebook.Name);
        Console.WriteLine();
        
        byte[] image = ReadFully(File.OpenRead("enlogo.png"));
        byte[] hash = new MD5CryptoServiceProvider().ComputeHash(image);
        string hashHex = BitConverter.ToString(hash).Replace("-", "").ToLower();
        
        Data data = new Data();
        data.Size = image.Length;
        data.BodyHash = hash;
        data.Body = image;
        
        Resource resource = new Resource();
        resource.Mime = "image/png";
        resource.Data = data;
        
        Note note = new Note();
        note.NotebookGuid = defaultNotebook.Guid;
        note.Title = "Test note from EDAMTest.cs";
        note.Content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
            "<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">" +
            "<en-note>Here's the Evernote logo:<br/>" +
            "<en-media type=\"image/png\" hash=\"" + hashHex + "\"/>" +
            "</en-note>";

        note.Resources = new List<Resource>();
        note.Resources.Add(resource);
        
        Note createdNote = noteStore.createNote(authToken, note);
        
        Console.WriteLine("Successfully created new note with GUID: " + createdNote.Guid);
    }
 public Find002Test(String authToken, NoteStore.Client noteStore)
 {
     mAuthToken = authToken;
     mNoteStore = noteStore;
 }
Example #19
0
        /*private ProgressStatusClass ProgressStatus;*/
        public frmMain()
        {
            InitializeComponent();

            setWorkingMode(true);

            lblInfo.Text = "Loading...";

            this.Show();
            this.Cursor = Cursors.WaitCursor;

            Application.DoEvents();

            //Registre = Registry.CurrentUser.CreateSubKey(@"Software\Calexo\CaMuMa");
            Registre = Registry.CurrentUser.OpenSubKey(@"Software\Calexo\CaMuMa", true);
            if (Registre == null) Registre = Registry.CurrentUser.CreateSubKey(@"Software\Calexo\CaMuMa");
            myParams = new Parameters();
            loadParams();

            //ProgressStatus = new ProgressStatusClass();

            userStoreUrl = new Uri(edamBaseUrl + "/edam/user");
            userStoreTransport = new THttpClient(userStoreUrl);
            userStoreProtocol = new TBinaryProtocol(userStoreTransport);
            userStore = new UserStore.Client(userStoreProtocol);

            sFolderList = new String[65535];

            Application.DoEvents();

            bool versionOK = userStore.checkVersion("CaMuMa",
                                    Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MAJOR,
                                    Evernote.EDAM.UserStore.Constants.EDAM_VERSION_MINOR);
            //Console.WriteLine("Is my EDAM protocol version up to date? " + versionOK);

            Application.DoEvents();

            if (!versionOK)
            {
                MessageBox.Show("Version KO");
            }
            /*else
            {
                //lblInfo.Text = "Ready...";
            }*/

            userStoreProt = new TBinaryProtocol(new THttpClient(userStoreUrl));
            userStore = new UserStore.Client(userStoreProt, userStoreProt);
            try
            {
                notestoreUrl = new Uri(userStore.getNoteStoreUrl(myParams.DevKey));
                // Set up the NoteStore client
                noteStoreTrans = new THttpClient(notestoreUrl);
                //noteStoreTrans.setCustomHeader("User-Agent", "Calexo CaMuMa");
                //noteStoreTrans.CustomHeaders.Add(

                noteStoreProt = new TBinaryProtocol(noteStoreTrans);
                noteStore = new NoteStore.Client(noteStoreProt, noteStoreProt);

                authToken = myParams.DevKey;

                notebooks = noteStore.listNotebooks(authToken);
                Console.WriteLine("Found " + notebooks.Count + " notebooks");
                //musicNotebook = notebooks[0];
                cmbNotebook.Items.Clear();
                foreach (Notebook notebook in notebooks)
                {
                    // Console.WriteLine("  * " + notebook.Name);
                    cmbNotebook.Items.Add(notebook.Name);
                    //if (notebook.DefaultNotebook)
                    if (notebook.Name == myParams.Notebook)
                    {
                        musicNotebook = notebook;
                        cmbNotebook.Text = notebook.Name;
                    }
                }

                Application.DoEvents();

                tags = noteStore.listTags(authToken);
                Console.WriteLine("Found " + tags.Count + " tags");
                lblInfo.Text = "Ready !";

                setWorkingMode(false);
            }
            catch (Evernote.EDAM.Error.EDAMUserException e)
            {
                //mes e.ErrorCode;
                lblInfo.Text = "ERREUR : "  + e.ErrorCode;

                setWorkingMode(false);

                btnGo.Enabled = false;
            }

            this.Cursor = DefaultCursor;
        }