Example #1
0
    def list_notes(self, notebook):
        # ノート検索条件を指定。ノートブックのIDを指定。更新日でソート
        note_filter = NoteFilter()
        note_filter.notebookGuid = notebook.guid
        note_filter.order = NoteSortOrder.UPDATED

        # ノート検索結果のフォーマットを指定。タイトルを含む
        result_format = NotesMetadataResultSpec()
        result_format.includeTitle = True

        # ノートのメタデータリストを取得
        note_meta_list = self.note_store.findNotesMetadata(note_filter, 0, 10, result_format)
        return [Note(self, note_meta) for note_meta in note_meta_list.notes]
Example #2
0
def get_notes(userStore, noteStore):
    guid = get_site_notebook().guid
    published_guid = get_published_tag(guid)

    note_filter = NoteFilter()
    note_filter.notebookGuid = guid
    note_filter.order = NoteSortOrder.CREATED
    note_filter.tagGuids = [published_guid]
    spec = NotesMetadataResultSpec(includeTitle=True,
                                   includeCreated=True,
                                   includeUpdated=True,
                                   includeNotebookGuid=True,
                                   includeTagGuids=True)
    notes = noteStore.findNotesMetadata(note_filter, 0, 100, spec).notes
    return notes
    def get_note_filter(self,start_time,notebook_name,end_time=None):

        for notebook in self.get_note_store().listNotebooks():
            if notebook.name == notebook_name:
                event_notebook_guid = notebook.guid
                break

        if event_notebook_guid is None:
            raise EvernoteConnectorException("Unable to find a notebook with the name '" + notebook_name + "'")

        note_filter = NoteFilter()
        note_filter.order = NoteSortOrder.CREATED
        note_filter.ascending = True
        note_filter.notebookGuid = event_notebook_guid
        if end_time is None:
            note_filter.words = "created:" + start_time + "Z"
        else:
            note_filter.words = "created:" + start_time + "Z -" + end_time

        return note_filter
Example #4
0
    def get_note_filter(self, start_time, notebook_name, end_time=None):

        for notebook in self.get_note_store().listNotebooks():
            if notebook.name == notebook_name:
                event_notebook_guid = notebook.guid
                break

        if event_notebook_guid is None:
            raise EvernoteConnectorException(
                "Unable to find a notebook with the name '" + notebook_name +
                "'")

        note_filter = NoteFilter()
        note_filter.order = NoteSortOrder.CREATED
        note_filter.ascending = True
        note_filter.notebookGuid = event_notebook_guid
        if end_time is None:
            note_filter.words = "created:" + start_time + "Z"
        else:
            note_filter.words = "created:" + start_time + "Z -" + end_time

        return note_filter
Example #5
0
def find_recent_notes(recent_days=1):
    logger.info("function starting - find_recent_notes: %d", recent_days)
    filter = NoteFilter()
    filter.ascending = True
    filter.order = NoteSortOrder.UPDATED
    filter.words = "updated:day-" + str(recent_days)
    spec = NotesMetadataResultSpec()
    spec.includeTitle = True
    spec.includeUpdated = True

    offset = 0
    pagesize = 50
    while True:
        logger.info("fetching, offset: %d", offset)
        result = get_store().findNotesMetadata(token, filter, offset, pagesize, spec)
        logger.info("fetched %d out of %d notes", len(result.notes), result.totalNotes)
        for metadata in result.notes:
            yield note_by_guid(metadata.guid)

        offset += pagesize

        if result.totalNotes <= offset:
            break
Example #6
0
def hello():
    global latestNote
    global updated
    global created

    auth_token = "S=s1:U=6eb51:E=146ce55b0ee:C=13f76a484f1:P=1cd:A=en-devtoken:V=2:H=5d05df82a62652c0ed8f2e544df37758"

    if auth_token == "":
        print "Please fill in your developer token"
        print "To get a developer token, visit " \
                "https://sandbox.evernote.com/api/DeveloperToken.action"
        exit(1)

    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()
    nb = None
    #print "Found ", len(notebooks), " notebooks:"
    for notebook in notebooks:
        #print "  * ", notebook.name
        if notebook.name == "Note":
            nb = notebook;
            break

    if not nb:
        print "Note book is not found in your account"
        exit(1)

    filter = NoteFilter()
    filter.notebookGuid = nb.guid
    filter.order = Types.NoteSortOrder.UPDATED

    spec = NotesMetadataResultSpec()
    spec.includeTitle = True

    noteML = note_store.findNotesMetadata(auth_token, filter, 0, 1, spec)
    content = ""
    content_org = ""
    content_new = ""

    for note in noteML.notes:
        noteID = note.guid

        if note.created == created and note.updated == updated:
            content = latestNote
        else:
            content = note_store.getNoteContent(auth_token, noteID);
            latestNote = content
            created = note.created
            updated = note.updated

        m = re.search(r'<en-note><div>(?P<content>.+)</div></en-note>', content)
        if m:
            content_org = "%s\n" % m.group('content')
            content = re.sub('<[^>]*>', '', content_org)
            line = '''<tspan x="%d" y="%d">%s</tspan>'''

            n = 57
            m = 0
            index = n
            y_aix = 450
            length = len(content)

            while index <= length:
                while ord(content[index-1]) < 128 and content[index-1] != ' ' and index != length:
                    index = index - 1
                index = ( m+n if index == m else index)
                content_new += line%(300, y_aix, content[m:index])

                if index == length:
                    break
                y_aix = y_aix + 30
                m = index
                index = index + n
                if index > length:
                    index = length

        content_new = content_new.decode('utf-8')
        content_org = content_org.decode('utf-8')

    #output = weather.getAndDraw()
    output = getWeather.w2svg("forecast")

    #output = codecs.open('weather-script-output.svg', 'r', encoding='utf-8').read()
    output = output.replace('NOTE_TEXT', content_new)
    output = output.replace('NOTE_ORG', content_org)

    ## Write output
    #codecs.open('weather.svg', 'w', encoding='utf-8').write(output)

    return output
Example #7
0
from evernote.edam.notestore.ttypes import NoteFilter
import evernote.edam.type.ttypes as Types

from evernote.api.client import EvernoteClient

# Sandbox: https://sandbox.evernote.com/api/DeveloperToken.action
# Production: https://www.evernote.com/api/DeveloperToken.action
auth_token = "S=s1:U=8f65c:E=14fa7113473:C=1484f600570:P=1cd:A=en-devtoken:V=2:H=484744fd0ffa906797416ae02ce5cd9c"

client = EvernoteClient(token=auth_token, sandbox=True)

note_store = client.get_note_store()

# GET CONTENT
noteFilter = NoteFilter()
noteFilter.order = 1 #http://dev.evernote.com/documentation/reference/Types.html#Enum_NoteSortOrder
noteFilter.ascending = False
noteList = note_store.findNotes(auth_token, noteFilter, 0, 50 )

guid = "3d958539-6cb7-4bd3-94a7-0240069ad9fb"

content = note_store.getNoteContent( auth_token, guid )

print content


sys.exit()


# Listar todos notebooks:
notebooks = note_store.listNotebooks()