Changeset 854:3e7dca86c1ed for src

Timestamp:

05/21/17 15:21:55 (8 years ago)

Author:

István Váradi <ivaradi@…>

Branch:

default

Phase:

public

Message:

The accepted flights can be queried and viewed (re #307)

Location:

src/mlx

Files:

• gui/flight.py (modified) (1 diff)
• gui/flightlist.py (modified) (9 diffs)
• gui/gui.py (modified) (4 diffs)
• pirep.py (modified) (1 diff)
• rpc.py (modified) (4 diffs)
• web.py (modified) (2 diffs)

src/mlx/gui/flight.py

@@ -5556 +5556 @@
             if result.loggedIn:
                 self._loginResult = result
+                self.gui.loginSuccessful()
             else:
                 if isReload:

src/mlx/gui/flightlist.py

@@ -12 +12 @@
     """A descriptor for a column in the list."""
     def __init__(self, attribute, heading, type = str,
-                 convertFn = None, renderer = gtk.CellRendererText(),
+                 convertFn = None, renderer = None,
                  extraColumnAttributes = None, sortable = False,
-                 defaultSortable = False):
+                 defaultSortable = False, defaultDescending = False,
+                 cellDataFn = None):
         """Construct the descriptor."""
         self._attribute = attribute
@@ -20 +21 @@
         self._type = type
         self._convertFn = convertFn
-        self._renderer = renderer
+        self._renderer = \
+          gtk.CellRendererText() if renderer is None else renderer
         self._extraColumnAttributes = extraColumnAttributes
         self._sortable = sortable
         self._defaultSortable = defaultSortable
+        self._defaultDescending = defaultDescending
+        self._cellDataFn = cellDataFn
 
     @property
@@ -38 +42 @@
 
         @param index is the 0-based index of the column."""
-        if self._extraColumnAttributes is None:
-            if isinstance(self._renderer, gtk.CellRendererText):
-                extraColumnAttributes = {"text" : index}
-            else:
-                extraColumnAttributes = {}
-        else:
-            extraColumnAttributes = self._extraColumnAttributes
-
         column = gtk.TreeViewColumn(self._heading, self._renderer,
                                     text = index)
@@ -53 +49 @@
             column.set_sort_indicator(True)
 
+        if self._extraColumnAttributes is not None:
+            for (key, value) in self._extraColumnAttributes.iteritems():
+                if key=="alignment":
+                    self._renderer.set_alignment(value, 0.5)
+                else:
+                    raise Exception("unhandled extra column attribute '" +
+                                    key + "'")
+        if self._cellDataFn is not None:
+            column.set_cell_data_func(self._renderer, self._cellDataFn)
+
         return column
 
     def getValueFrom(self, flight):
         """Get the value from the given flight."""
-        value = getattr(flight, self._attribute)
+        attributes = self._attribute.split(".")
+        value = getattr(flight, attributes[0])
+        for attr in attributes[1:]:
+            value = getattr(value, attr)
         return self._type(value) if self._convertFn is None \
             else self._convertFn(value, flight)
@@ -96 +105 @@
         self._model = gtk.ListStore(*types)
         if defaultSortableIndex is not None:
-            self._model.set_sort_column_id(defaultSortableIndex,
-                                           SORT_ASCENDING)
+            sortOrder = SORT_DESCENDING \
+              if self._columnDescriptors[defaultSortableIndex-1]._defaultDescending \
+              else SORT_ASCENDING
+            self._model.set_sort_column_id(defaultSortableIndex, sortOrder)
         self._view = gtk.TreeView(self._model)
 
@@ -223 +234 @@
 
     It contains the list and the buttons available."""
+    @staticmethod
     def getAircraft(tailNumber, bookedFlight):
         """Get the aircraft from the given booked flight.
@@ -230 +242 @@
         return tailNumber + \
             " (" + const.icaoCodes[bookedFlight.aircraftType] + ")"
+
+    def _getAcft(tailNumber, bookedFlight):
+        return PendingFlightsFrame.getAircraft(tailNumber, bookedFlight)
 
     columnDescriptors = [
@@ -240 +255 @@
                          sortable = True),
         ColumnDescriptor("tailNumber", xstr("pendflt_acft"),
-                         convertFn = getAircraft)
+                         convertFn = _getAcft)
     ]
 
@@ -501 +516 @@
 
 #-----------------------------------------------------------------------------
+
+class AcceptedFlightsWindow(gtk.Window):
+    """A window for a list of accepted flights."""
+    def getFlightDuration(flightTimeStart, flight):
+        """Get the flight duration for the given flight."""
+        minutes = int(round((flight.flightTimeEnd - flightTimeStart)/60.0))
+        return "%02d:%02d" % (minutes/60, minutes%60)
+
+    columnDescriptors = [
+        ColumnDescriptor("bookedFlight.callsign", xstr("flightsel_no")),
+        ColumnDescriptor("bookedFlight.departureTime", xstr("flightsel_deptime"),
+                         sortable = True, defaultSortable = True,
+                         defaultDescending = True),
+        ColumnDescriptor("bookedFlight.departureICAO", xstr("flightsel_from"),
+                         sortable = True),
+        ColumnDescriptor("bookedFlight.arrivalICAO", xstr("flightsel_to"),
+                         sortable = True),
+        ColumnDescriptor("bookedFlight.tailNumber", xstr("pendflt_acft"),
+                         convertFn = lambda value, flight:
+                         PendingFlightsFrame.getAircraft(value,
+                                                         flight.bookedFlight)),
+        ColumnDescriptor("flightTimeStart", xstr("acceptedflt_flight_duration"),
+                         convertFn = getFlightDuration, sortable = True,
+                         extraColumnAttributes =
+                             { "alignment": 0.5 } ),
+        ColumnDescriptor("numPassengers", xstr("acceptedflt_num_pax"),
+                         type = int, sortable = True,
+                         extraColumnAttributes =
+                             { "alignment": 1.0 } ),
+        ColumnDescriptor("fuelUsed", xstr("acceptedflt_fuel"),
+                         type = int, sortable = True,
+                         extraColumnAttributes =
+                             { "alignment": 1.0 } ),
+        ColumnDescriptor("rating", xstr("acceptedflt_rating"),
+                         type = float, sortable = True,
+                         extraColumnAttributes =
+                             { "alignment": 1.0 },
+                         cellDataFn = lambda col, cell, model, iter:
+                             cell.set_property("text",
+                                               "%.0f" %
+                                               (model.get(iter, 9)[0],)))
+    ]
+
+    def __init__(self, gui):
+        """Construct the window."""
+        super(AcceptedFlightsWindow, self).__init__()
+
+        self._gui = gui
+
+        self.set_title(WINDOW_TITLE_BASE + " - " + xstr("acceptedflt_title"))
+        self.set_size_request(-1, 700)
+        self.set_transient_for(gui.mainWindow)
+
+        alignment = gtk.Alignment(xscale = 1.0, yscale = 1.0)
+        alignment.set_padding(padding_top = 2, padding_bottom = 8,
+                              padding_left = 4, padding_right = 4)
+
+        vbox = gtk.VBox()
+
+        hbox = gtk.HBox()
+        vbox.pack_start(hbox, True, True, 4)
+
+        self._flights = []
+        self._flightList = FlightList(columnDescriptors =
+                                      AcceptedFlightsWindow.columnDescriptors,
+                                      widthRequest = 750,
+                                      multiSelection = False)
+        self._flightList.connect("selection-changed", self._selectionChanged)
+
+        hbox.pack_start(self._flightList, True, True, 4)
+
+        buttonBox = gtk.VBox()
+
+        self._refreshButton = gtk.Button(xstr("acceptedflt_refresh"))
+        self._refreshButton.set_sensitive(True)
+        self._refreshButton.connect("clicked", self._refreshClicked)
+        buttonBox.pack_start(self._refreshButton, False, False, 2)
+
+        filler = gtk.Alignment(xalign = 0.0, yalign = 0.0,
+                               xscale = 1.0, yscale = 1.0)
+        filler.set_size_request(-1, 4)
+        buttonBox.pack_start(filler, False, False, 0)
+
+        self._viewButton = gtk.Button(xstr("acceptedflt_view"))
+        self._viewButton.set_sensitive(False)
+        self._viewButton.connect("clicked", self._viewClicked)
+        buttonBox.pack_start(self._viewButton, False, False, 2)
+
+        hbox.pack_start(buttonBox, False, False, 4)
+
+        buttonAlignment = gtk.Alignment(xscale = 0.0, yscale = 0.0,
+                                        xalign = 0.5, yalign = 0.5)
+
+        self._closeButton =  gtk.Button(xstr("button_ok"))
+        self._closeButton.connect("clicked", self._closeClicked)
+
+        buttonAlignment.add(self._closeButton)
+        vbox.pack_start(buttonAlignment, False, False, 2)
+
+        alignment.add(vbox)
+
+        self.add(alignment)
+
+        self.connect("key-press-event", self._keyPressed)
+
+    @property
+    def hasFlights(self):
+        """Determine if there are any flights that we know of."""
+        return len(self._flights)>0
+
+    def clear(self):
+        """Clear the flight list."""
+        self._flights = []
+        self._flightList.clear()
+
+    def addFlight(self, flight):
+        """Add the given flight."""
+        self._flights.append(flight)
+        self._flightList.addFlight(flight)
+
+    def _selectionChanged(self, flightList, selectedIndexes):
+        """Called when the selection has changed."""
+        self._viewButton.set_sensitive(len(selectedIndexes)==1)
+
+    def _refreshClicked(self, button):
+        """Called when the refresh button has been clicked."""
+        self.clear()
+        self._gui.showFlights(None)
+
+    def _viewClicked(self, button):
+        """Called when the view button has been clicked."""
+        gui = self._gui
+        gui.beginBusy(xstr("pendflt_pirep_busy"))
+        self.set_sensitive(False)
+
+        indexes = self._flightList.selectedIndexes
+        assert(len(indexes)==1)
+
+        flightID = self._flights[indexes[0]].bookedFlight.id
+        gui.webHandler.getPIREP(self._pirepResultCallback, flightID)
+
+    def _pirepResultCallback(self, returned, result):
+        """Called when the PIREP query result is available."""
+        gobject.idle_add(self._handlePIREPResult, returned, result)
+
+    def _handlePIREPResult(self, returned, result):
+        """Handle the refly result."""
+        self.set_sensitive(True)
+        gui = self._gui
+        gui.endBusy()
+
+        if returned:
+            gui.viewPIREP(result.pirep)
+
+    def _closeClicked(self, button):
+        """Called when the Close button is clicked.
+
+        A 'delete-event' is emitted to close the window."""
+        self.emit("delete-event", None)
+
+    def _keyPressed(self, window, event):
+        """Called when a key is pressed in the window.
+
+        If the Escape key is pressed, 'delete-event' is emitted to close the
+        window."""
+        if gdk.keyval_name(event.keyval) == "Escape":
+            self.emit("delete-event", None)
+            return True
+
+#-----------------------------------------------------------------------------

src/mlx/gui/gui.py

@@ -13 +13 @@
 from mlx.gui.checklist import ChecklistEditor
 from mlx.gui.callouts import ApproachCalloutsEditor
+from mlx.gui.flightlist import AcceptedFlightsWindow
 from mlx.gui.pirep import PIREPViewer, PIREPEditor
 from mlx.gui.bugreport import BugReportDialog
@@ -119 +120 @@
 
         self._preferences = Preferences(self)
+        self._flightsWindow = AcceptedFlightsWindow(self)
+        self._flightsWindow.connect("delete-event", self._hideFlightsWindow)
         self._checklistEditor = ChecklistEditor(self)
         self._approachCalloutsEditor = ApproachCalloutsEditor(self)
@@ -1059 +1062 @@
         toolsMenuItem.set_submenu(toolsMenu)
         menuBar.append(toolsMenuItem)
+
+        self._flightsMenuItem = flightsMenuItem = \
+          gtk.ImageMenuItem(gtk.STOCK_SPELL_CHECK)
+        flightsMenuItem.set_use_stock(True)
+        flightsMenuItem.set_label(xstr("menu_tools_flights"))
+        flightsMenuItem.add_accelerator("activate", accelGroup,
+                                        ord(xstr("menu_tools_flights_key")),
+                                        CONTROL_MASK, ACCEL_VISIBLE)
+        flightsMenuItem.connect("activate", self.showFlights)
+        self._flightsMenuItem.set_sensitive(False)
+        toolsMenu.append(flightsMenuItem)
 
         checklistMenuItem = gtk.ImageMenuItem(gtk.STOCK_APPLY)
@@ -1222 +1236 @@
             self._mainWindow.set_default(None)
 
+    def loginSuccessful(self):
+        """Called when the login is successful."""
+        self._flightsMenuItem.set_sensitive(True)
+
     def isWizardActive(self):
         """Determine if the flight wizard is active."""
         return self._notebook.get_current_page()==0
+
+    def showFlights(self, menuItem):
+        """Callback for showing the flight list."""
+        if self._flightsWindow.hasFlights:
+            self._flightsWindow.show_all()
+        else:
+            self.beginBusy(xstr("acceptedflt_query_busy"))
+            self.webHandler.getAcceptedFlights(self._acceptedFlightsCallback)
+
+    def _acceptedFlightsCallback(self, returned, result):
+        """Called when the accepted flights have been received."""
+        gobject.idle_add(self._handleAcceptedFlights, returned, result)
+
+    def _handleAcceptedFlights(self, returned, result):
+        """Handle the result of the query for accepted flights."""
+        self.endBusy()
+        if returned:
+            self._flightsWindow.clear()
+            for flight in result.flights:
+                self._flightsWindow.addFlight(flight)
+            self._flightsWindow.show_all()
+        else:
+            dialog = gtk.MessageDialog(parent = self.mainWindow,
+                                       type = MESSAGETYPE_ERROR,
+                                       message_format = xstr("acceptedflt_failed"))
+            dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
+            dialog.set_title(WINDOW_TITLE_BASE)
+            dialog.run()
+            dialog.hide()
+
+    def _hideFlightsWindow(self, window, event):
+        """Hide the window of the accepted flights."""
+        self._flightsWindow.hide()
+        return True
 
     def _editChecklist(self, menuItem):

src/mlx/pirep.py

@@ -170 +170 @@
 
         self.filedCruiseAltitude = int(pirepData["filedCruiseLevel"][2:])*100
-        cruiseLevel = pirepData["cruiseLevel"]
+        cruiseLevel = pirepData["cruiseLevel"].strip()
+        if cruiseLevel:
+            if cruiseLevel.startswith("FL"):
+                cruiseLevel = cruiseLevel[2:]
         if cruiseLevel:
             self.cruiseAltitude = int(cruiseLevel[2:])*100

src/mlx/rpc.py

@@ -7 +7 @@
 import hashlib
 import datetime
+import calendar
+import sys
 
 #---------------------------------------------------------------------------------------
@@ -32 +34 @@
                     continue
 
-                value = instruction(value)
+                try:
+                    value = instruction(value)
+                except:
+                    print >> sys.stderr, "Failed to convert value '%s' of attribute '%s':" % \
+                        (value, key)
+                    import traceback
+                    traceback.print_exc()
             setattr(self, key, value)
 
@@ -131 +139 @@
 #---------------------------------------------------------------------------------------
 
+class AcceptedFlight(RPCObject):
+    """A flight that has been already accepted."""
+    # The instructions for the construction
+    @staticmethod
+    def parseTimestamp(s):
+        """Parse the given RPC timestamp."""
+        dt = datetime.datetime.strptime(s, "%Y-%m-%d %H:%M:%S")
+        return calendar.timegm(dt.utctimetuple())
+
+    _instructions = {
+        "bookedFlight" : lambda value: BookedFlight(value),
+        "numPassengers" : int,
+        "fuelUsed" : int,
+        "rating" : lambda value: float(value) if value else 0.0
+        }
+
+    def __init__(self, value):
+        """Construct the booked flight object from the given RPC result
+        value."""
+        super(AcceptedFlight, self).__init__(value, AcceptedFlight._instructions)
+        self.flightTimeStart = \
+          AcceptedFlight.parseTimestamp(self.flightDate + " " +
+                                        self.flightTimeStart)
+        self.flightTimeEnd = \
+          AcceptedFlight.parseTimestamp(self.flightDate + " " +
+                                        self.flightTimeEnd)
+        if self.flightTimeEnd<self.flightTimeStart:
+            self.flightTimeEnd += 24*60*60
+
+#---------------------------------------------------------------------------------------
+
 class Plane(rpccommon.Plane, RPCObject):
     """An airplane in the fleet."""
@@ -299 +338 @@
         return (bookedFlights, reportedFlights, rejectedFlights)
 
+    def getAcceptedFlights(self):
+        """Get the flights that are already accepted."""
+        value = self._performCall(lambda sessionID:
+                                  self._server.getAcceptedFlights(sessionID))
+        flights = []
+        for flight in value:
+            flights.append(AcceptedFlight(flight))
+        return flights
+
     def getEntryExamStatus(self):
         """Get the status of the exams needed for joining MAVA."""

src/mlx/web.py

@@ -1326 +1326 @@
 #------------------------------------------------------------------------------
 
+class GetAcceptedFlights(RPCRequest):
+    """Request to get the accepted flights."""
+    def __init__(self, client, callback):
+        """Construct the request with the given client and callback function."""
+        super(GetAcceptedFlights, self).__init__(client, callback)
+
+    def run(self):
+        """Perform the login request."""
+        result = Result()
+
+        result.flights = self._client.getAcceptedFlights()
+
+        return result
+
+#------------------------------------------------------------------------------
+
 class Handler(threading.Thread):
     """The handler for the web services.
@@ -1419 +1435 @@
         self._addRequest(DeleteFlights(self._rpcClient, callback, flightIDs))
 
+    def getAcceptedFlights(self, callback):
+        """Enqueue a request to get the accepted flights."""
+        self._addRequest(GetAcceptedFlights(self._rpcClient, callback))
+
     def run(self):
         """Process the requests."""