Switch application logic over to HistoryManager, re-do getForeign(), fixup populate()

bulk_reminders/gui.py

@@ -1,4 +1,3 @@
-import itertools
 from typing import Iterator, List
 
 from PyQt5 import QtCore, QtGui, QtWidgets
@@ -9,6 +8,7 @@ from bulk_reminders.api import Event
 from bulk_reminders.gui_base import Ui_MainWindow
 from bulk_reminders.load import LoadDialog
 from bulk_reminders.oauth import OAuthDialog
+from bulk_reminders.undo import IDPair, Stage
 
 
 class MainWindow(QMainWindow, Ui_MainWindow):
@@ -54,13 +54,15 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         self.undoButton.clicked.connect(self.undo)
         self.submitButton.clicked.connect(self.submit)
 
+        self.history = undo.HistoryManager('history.json')
+
         # Disable the undo button until undo stages are available
-        if len(undo.stages) == 0:
+        if len(self.history) == 0:
             self.undoButton.setDisabled(True)
 
         self.loadEventsButton.clicked.connect(self.load_events)
         self.cachedLoadText = ''
-        self.readyEvents = []
+        self.readyEvents: List[Event] = []
 
         self.populate()
 
@@ -78,33 +80,46 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
     def undo(self) -> None:
         # Get the latest undo stage and delete all events in that stage
-        latest = undo.stages.pop(0)
+        latest = self.history.pop()
-        for entry in latest:
+        for entry in latest.events:
-            self.calendar.service.events().delete(calendarId=entry.get('calendarId'), eventId=entry.get('eventId')).execute()
+            self.calendar.service.events().delete(calendarId=entry.calendarID, eventId=entry.eventID).execute()
 
         # Disable the undo button until undo stages are available
-        if len(undo.stages) == 0:
+        self.undoButton.setDisabled(len(self.history) == 0)
-            self.undoButton.setDisabled(True)
 
-    def getForeign(self) -> List[Event]:
+        self.populate()  # Refresh
+
+    def getForeign(self) -> Iterator[IDPair]:
         """Returns all events currently tracked that are not stored in the undo."""
-        events = {event['id'] : event for event in self.apiEvents}
+        undoableIDs = set(self.history.all_pairs())
-        undoableIDs = itertools.chain.from_iterable([[undoable['id'] for undoable in stage] for stage in undo.stages])
+        for apiEvent in self.apiEvents:
-        foreignIDs = events.keys() - undoableIDs
+            pair = IDPair(calendarID=self.currentCalendarID, eventID=apiEvent['id'])
-        return [events[foreignID] for foreignID in foreignIDs]
+            if pair not in undoableIDs:
+                yield pair
 
     def submit(self) -> None:
-        pass
+        newStage = Stage(index=self.history.nextIndex(), commonCalendar=self.currentCalendarID)
+        while self.readyEvents:
+            event: Event = self.readyEvents.pop(0)
+            result = self.calendar.service.events().insert(calendarId=self.currentCalendarID, body=event.body).execute()
+            newStage.events.append(IDPair(self.currentCalendarID, result.get('id')))
+
+        self.history.addStage(newStage)
+        self.populate()
 
     def populate(self) -> None:
         """Re-populate the table with all of the events"""
         self.apiEvents = self.calendar.getEvents(self.currentCalendarID)
-        self.events = [Event.from_api(event) for event in self.apiEvents]
+
-        ready, undoable, stage, foreign = len(self.readyEvents), undo.getTotal(), len(undo.stages), len(self.getForeign())
+        events = list(self.readyEvents)
-        total = ready + undoable + stage + foreign
+        events.extend([Event.from_api(event, self.history) for event in self.apiEvents])
+
+        ready, undoable, stage, foreign = len(self.readyEvents), self.history.getTotal(), len(self.history), len(list(self.getForeign()))
+        total = ready + undoable + foreign
         self.eventCountLabel.setText(f'{len(self.readyEvents)} ready, {undoable} undoable in {stage} stages, {foreign} foreign ({total})')
-        self.eventsView.setRowCount(len(self.events))
+
-        for row, event in enumerate(self.events):
+        self.eventsView.setRowCount(len(events))
+        for row, event in enumerate(events):
             event.fill_row(row, self.eventsView)
 
     @QtCore.pyqtSlot(int)

bulk_reminders/undo.py

@@ -32,12 +32,12 @@ class HistoryManager(object):
         """Returns the total number of undoable events known."""
         return sum(len(stage) for stage in self.stages)
 
-    def exists(self, id: 'IDPair') -> int:
+    def exists(self, eventID: 'IDPair') -> int:
-        """Check if a given ID exists anywhere in the undo history data. Returns the stage index or -1 if it wasn't found."""
+        """Check if a given Event ID exists anywhere in the undo history data. Returns the stage index or -1 if it wasn't found."""
-        print(f'Checking for {id} in undo history')
+        print(f'Checking for {eventID} in undo history')
         for stage in self.stages:
             for undoable in stage.events:
-                if id == undoable.eventID:
+                if eventID == undoable.eventID:
                     return stage.index
         return -1