Merge pull request #13 from Scriptkiddi/aip1000

Aip1000

Author: Fritz Otlinghaus

Diff for: anknotes/__main__.py

@@ -16,17 +16,30 @@
 
 
 # Note: This class was adapted from the Real-Time_Import_for_use_with_the_Rikaisama_Firefox_Extension plug-in by [email protected]
-#.. itself adapted from Yomichan plugin by Alex Yatskov.
+# .. itself adapted from Yomichan plugin by Alex Yatskov.
 
 PATH = os.path.dirname(os.path.abspath(__file__))
 ONLY_ADD_NEW = True
+DO_UPDATE_NOTES = True
 EVERNOTE_MODEL = "evernote_note"
 TITLE_FIELD_NAME = "title"
 CONTENT_FIELD_NAME = "content"
 GUID_FIELD_NAME = "Evernote Guid"
 
 
 class Anki:
+    def update_evernote_cards(self, evernote_cards, tag):
+        count = 0
+        for card in evernote_cards:
+            anki_field_info = {TITLE_FIELD_NAME: card.front.decode('utf-8'),
+                               CONTENT_FIELD_NAME: card.back.decode('utf-8'),
+                               GUID_FIELD_NAME: card.guid}
+            card.tags.append(tag)
+            self.update_note(anki_field_info, card.tags)
+            count += 1
+        self.stop_editing()
+        return count
+
     def add_evernote_cards(self, evernote_cards, deck, tag):
         count = 0
         model_name = EVERNOTE_MODEL
@@ -40,6 +53,20 @@ def add_evernote_cards(self, evernote_cards, deck, tag):
         self.stop_editing()
         return count
 
+    def update_note(self, fields, tags=list()):
+        col = self.collection()
+        note_id = col.findNotes(fields[GUID_FIELD_NAME])[0]
+        note = anki.notes.Note(col, None, note_id)
+        note.tags = tags
+        for fld in note._model['flds']:
+            if TITLE_FIELD_NAME in fld.get('name'):
+                note.fields[fld.get('ord')] = fields[TITLE_FIELD_NAME]
+            elif CONTENT_FIELD_NAME in fld.get('name'):
+                note.fields[fld.get('ord')] = fields[CONTENT_FIELD_NAME]
+            # we dont have to update the evernote guid because if it changes we wont find this note anyway
+        note.flush()
+        return note.id
+
     def add_note(self, deck_name, model_name, fields, tags=list()):
         note = self.create_note(deck_name, model_name, fields, tags)
         if note is not None:
@@ -55,8 +82,8 @@ def create_note(self, deck_name, model_name, fields, tags=list()):
         col = self.collection()
         note = anki.notes.Note(col, model)
         note.model()['did'] = id_deck
-        tags = [tags]
         note.tags = tags
+
         for name, value in fields.items():
             note[name] = value
         return note
@@ -79,8 +106,8 @@ def add_evernote_model(self):  # adapted from the IREAD plug-in from Frank
             mm.addField(evernote_model, guid_field)
             # Add template
             t = mm.newTemplate('EvernoteReview')
-            t['qfmt'] = "{{"+TITLE_FIELD_NAME+"}}"
-            t['afmt'] = "{{"+CONTENT_FIELD_NAME+"}}"
+            t['qfmt'] = "{{" + TITLE_FIELD_NAME + "}}"
+            t['afmt'] = "{{" + CONTENT_FIELD_NAME + "}}"
             mm.addTemplate(evernote_model, t)
             mm.add(evernote_model)
             return evernote_model
@@ -91,22 +118,21 @@ def add_evernote_model(self):  # adapted from the IREAD plug-in from Frank
             source_ord, source_field = fmap[GUID_FIELD_NAME]
             source_field['sticky'] = False
 
-    def get_guids_from_anki_id(self,ids):
-        guids = []
+    def get_guids_from_anki_id(self, ids):
+        guids = {}
         for a_id in ids:
             card = self.collection().getCard(a_id)
             items = card.note().items()
             if len(items) == 3:
-                guids.append(items[2][1])  # not a very smart access
+                guids[str(a_id)] = items[2][1]  # not a very smart access
         return guids
 
     def can_add_note(self, deck_name, model_name, fields):
         return bool(self.create_note(deck_name, model_name, fields))
 
     def get_cards_id_from_tag(self, tag):
-        query = "tag:"+tag
+        query = "tag:" + tag
         ids = self.collection().findCards(query)
-        #show_tooltip(ids)
         return ids
 
     def start_editing(self):
@@ -142,7 +168,6 @@ def __init__(self, q, a, g, tags):
 
 
 class Evernote:
-
     def __init__(self):
         if not mw.col.conf.get('evernoteToken', False):
             # First run of the Plugin we did not save the access key yet
@@ -214,9 +239,34 @@ def proceed(self):
         anki_guids = self.anki.get_guids_from_anki_id(anki_ids)
         evernote_guids = self.get_evernote_guids_from_tag(self.evernoteTags)
         if ONLY_ADD_NEW:
-            note_guids_to_import = set(evernote_guids)-set(anki_guids)
-            n = self.import_into_anki(note_guids_to_import, self.deck, self.ankiTag)
-            show_tooltip(str(n) + " cards have been imported")
+            cards_to_add_or_update = self.dict_remove_duplicates(evernote_guids, anki_guids)
+            n = self.import_into_anki(cards_to_add_or_update['add'], self.deck, self.ankiTag)
+            n2 = 0
+            if DO_UPDATE_NOTES:
+                self.anki.start_editing()
+                self.update_in_anki(cards_to_add_or_update['update'], self.ankiTag)
+                n2 = len(cards_to_add_or_update['update'])
+
+            show_tooltip("{} existing card(s) have been updated (deleted and re-added) and {} new card(s) have been imported.".format(str(n2), str(n)))
+        self.anki.stop_editing()
+
+    def dict_remove_duplicates(self, evernote_guids, anki_guids):
+        notes_to_add = []
+        notes_to_update = []
+        for evernote_guid in evernote_guids:
+            for anki_id, anki_guid in anki_guids.items():
+                if anki_guid == evernote_guid:
+                    notes_to_update.append(evernote_guid)
+                    break
+            else:
+                notes_to_add.append(evernote_guid)
+        return {'add': notes_to_add, 'update': notes_to_update}
+
+    def update_in_anki(self, guid_set, tag):
+
+        cards = self.evernote.create_evernote_cards(guid_set)
+        number = self.anki.update_evernote_cards(cards, tag)
+        return number
 
     def import_into_anki(self, guid_set, deck, tag):
         cards = self.evernote.create_evernote_cards(guid_set)
@@ -228,7 +278,7 @@ def get_evernote_guids_from_tag(self, tags):
         for tag in tags:
             tag_guid = self.evernote.find_tag_guid(tag)
             if tag_guid is not None:
-                note_guids = note_guids+self.evernote.find_notes_filter_by_tag_guids([tag_guid])
+                note_guids = note_guids + self.evernote.find_notes_filter_by_tag_guids([tag_guid])
         return note_guids
 
 
@@ -237,73 +287,75 @@ def show_tooltip(text, time_out=3000):
 
 
 def main():
-    show_tooltip(str())
+    # show_tooltip(str())
     controller = Controller()
     controller.proceed()
 
+
 action = aqt.qt.QAction("Import from Evernote", aqt.mw)
 aqt.mw.connect(action, aqt.qt.SIGNAL("triggered()"), main)
 aqt.mw.form.menuTools.addAction(action)
 
 
 def setup_evernote(self):
-        global evernote_default_deck
-        global evernote_default_tag
-        global evernote_tags_to_import
-        global keep_evernote_tags
-
-        layout_tab = self.form.tab_1.layout()
-        group_box = QGroupBox("Evernote Importer")
-        layout = QVBoxLayout()
-
-        # Default Deck
-        evernote_default_deck_label = QLabel("Default Deck:")
-        evernote_default_deck = QLineEdit()
-        evernote_default_deck.setText(mw.col.conf.get('evernoteDefaultDeck', ""))
-        layout.insertWidget(int(layout.count())+1, evernote_default_deck_label)
-        layout.insertWidget(int(layout.count())+2, evernote_default_deck)
-        evernote_default_deck.connect(evernote_default_deck, SIGNAL("editingFinished()"), update_evernote_default_deck)
-
-        # Default Tag
-        evernote_default_tag_label = QLabel("Default Tag:")
-        evernote_default_tag = QLineEdit()
-        evernote_default_tag.setText(mw.col.conf.get('evernoteDefaultTag', ""))
-        layout.insertWidget(int(layout.count())+1, evernote_default_tag_label)
-        layout.insertWidget(int(layout.count())+2, evernote_default_tag)
-        evernote_default_tag.connect(evernote_default_tag, SIGNAL("editingFinished()"), update_evernote_default_tag)
-
-        # Tags to import
-        evernote_tags_to_import_label = QLabel("Tags to import:")
-        evernote_tags_to_import = QLineEdit()
-        evernote_tags_to_import.setText(mw.col.conf.get('evernoteTagsToImport', ""))
-        layout.insertWidget(int(layout.count())+1, evernote_tags_to_import_label)
-        layout.insertWidget(int(layout.count())+2, evernote_tags_to_import)
-        evernote_tags_to_import.connect(evernote_tags_to_import,
-                                        SIGNAL("editingFinished()"),
-                                        update_evernote_tags_to_import)
-
-        # keep evernote tags
-        keep_evernote_tags = QCheckBox("Keep Evernote Tags", self)
-        keep_evernote_tags.setChecked(mw.col.conf.get('evernoteKeepTags', False))
-        keep_evernote_tags.stateChanged.connect(update_evernote_keep_tags)
-        layout.insertWidget(int(layout.count())+1, keep_evernote_tags)
-        group_box.setLayout(layout)
-        layout_tab.insertWidget(int(layout.count())+1, group_box)
+    global evernote_default_deck
+    global evernote_default_tag
+    global evernote_tags_to_import
+    global keep_evernote_tags
+
+    layout_tab = self.form.tab_1.layout()
+    group_box = QGroupBox("Evernote Importer")
+    layout = QVBoxLayout()
+
+    # Default Deck
+    evernote_default_deck_label = QLabel("Default Deck:")
+    evernote_default_deck = QLineEdit()
+    evernote_default_deck.setText(mw.col.conf.get('evernoteDefaultDeck', ""))
+    layout.insertWidget(int(layout.count()) + 1, evernote_default_deck_label)
+    layout.insertWidget(int(layout.count()) + 2, evernote_default_deck)
+    evernote_default_deck.connect(evernote_default_deck, SIGNAL("editingFinished()"), update_evernote_default_deck)
+
+    # Default Tag
+    evernote_default_tag_label = QLabel("Default Tag:")
+    evernote_default_tag = QLineEdit()
+    evernote_default_tag.setText(mw.col.conf.get('evernoteDefaultTag', ""))
+    layout.insertWidget(int(layout.count()) + 1, evernote_default_tag_label)
+    layout.insertWidget(int(layout.count()) + 2, evernote_default_tag)
+    evernote_default_tag.connect(evernote_default_tag, SIGNAL("editingFinished()"), update_evernote_default_tag)
+
+    # Tags to import
+    evernote_tags_to_import_label = QLabel("Tags to import:")
+    evernote_tags_to_import = QLineEdit()
+    evernote_tags_to_import.setText(mw.col.conf.get('evernoteTagsToImport', ""))
+    layout.insertWidget(int(layout.count()) + 1, evernote_tags_to_import_label)
+    layout.insertWidget(int(layout.count()) + 2, evernote_tags_to_import)
+    evernote_tags_to_import.connect(evernote_tags_to_import,
+                                    SIGNAL("editingFinished()"),
+                                    update_evernote_tags_to_import)
+
+    # keep evernote tags
+    keep_evernote_tags = QCheckBox("Keep Evernote Tags", self)
+    keep_evernote_tags.setChecked(mw.col.conf.get('evernoteKeepTags', False))
+    keep_evernote_tags.stateChanged.connect(update_evernote_keep_tags)
+    layout.insertWidget(int(layout.count()) + 1, keep_evernote_tags)
+    group_box.setLayout(layout)
+    layout_tab.insertWidget(int(layout.count()) + 1, group_box)
 
 
 def update_evernote_default_deck():
-        mw.col.conf['evernoteDefaultDeck'] = evernote_default_deck.text()
+    mw.col.conf['evernoteDefaultDeck'] = evernote_default_deck.text()
 
 
 def update_evernote_default_tag():
-        mw.col.conf['evernoteDefaultTag'] = evernote_default_tag.text()
+    mw.col.conf['evernoteDefaultTag'] = evernote_default_tag.text()
 
 
 def update_evernote_tags_to_import():
-        mw.col.conf['evernoteTagsToImport'] = evernote_tags_to_import.text()
+    mw.col.conf['evernoteTagsToImport'] = evernote_tags_to_import.text()
 
 
 def update_evernote_keep_tags():
-        mw.col.conf['evernoteKeepTags'] = keep_evernote_tags.isChecked()
+    mw.col.conf['evernoteKeepTags'] = keep_evernote_tags.isChecked()
+
 
 Preferences.setupOptions = wrap(Preferences.setupOptions, setup_evernote)