Add create episode function.

dsst/dsst_gtk3/dialogs.py

@@ -4,6 +4,7 @@ This module contains UI functions for displaying different dialogs
 import datetime
 from gi.repository import Gtk
 from common import models
+from dsst_gtk3 import gtk_ui
 
 
 def enter_string_dialog(builder: Gtk.Builder, title: str, value=None) -> str:
@@ -56,78 +57,44 @@ def edit_season(builder: 'Gtk.Builder', season: 'models.Season'=None):
     return season
 
 
-def show_episode_dialog(builder: Gtk.Builder, title: str, season_id: int, episode):
+def edit_episode(app: 'gtk_ui.GtkUi', season_id: int, episode: 'models.Episode'=None):
-    """ Shows a dialog to edit an episode
+    """Show an dialog to create or edit episodes
-    :param builder: GtkBuilder with loaded 'dialogs.glade'
+    :param app: Reference to main UI application
-    :param title: Title of the dialog window
+    :param season_id: Is of the season in which the episode appears
-    :param season_id: Season to witch the episode should be added
+    :param episode: Existing episode object to edit
-    :param episode: (Optional) Existing episode to edit
+    :return: Edited episode object, or None if the process was canceled
-    :return True if changes where saved False if discarded
     """
-    pass
+    if not episode:
-    # # Set up the dialog
+        episode = models.Episode()
-    # dialog = builder.get_object("edit_episode_dialog")  # type: Gtk.Dialog
+        episode.date = datetime.datetime.today()
-    # dialog.set_transient_for(builder.get_object("main_window"))
+        episode.number = 1
-    # dialog.set_title(title)
+        episode.name = ''
-    # with sql.db.atomic():
+        episode.players = []
-    #     if not episode:
-    #         nxt_number = len(sql.Season.get_by_id(season_id).episodes) + 1
-    #         episode = sql.Episode.create(seq_number=nxt_number, number=nxt_number, date=datetime.today(),
-    #                                      season=season_id)
-    #     # Set episode number
-    #     builder.get_object("episode_no_spin_button").set_value(episode.number)
-    #     # Set episode date
-    #     builder.get_object('episode_calendar').select_month(episode.date.month, episode.date.year)
-    #     builder.get_object('episode_calendar').select_day(episode.date.day)
-    #     # Set participants for the episode
-    #     builder.get_object('episode_players_store').clear()
-    #     for player in episode.players:
-    #         builder.get_object('episode_players_store').append([player.id, player.name, player.hex_id])
-    #
-    #     result = dialog.run()
-    #     dialog.hide()
-    #
-    #     if result != Gtk.ResponseType.OK:
-    #         sql.db.rollback()
-    #         return False
-    #
-    #     # Save all changes to Database
-    #     player_ids = [row[0] for row in builder.get_object('episode_players_store')]
-    #     # Insert new Players
-    #     episode.players = sql.Player.select().where(sql.Player.id << player_ids)
-    #     # Update Date of the Episode
-    #     cal_value = builder.get_object('episode_calendar').get_date()
-    #     selected_date = datetime(*cal_value).date()
-    #     episode.date = selected_date,
-    #     episode.number = int(builder.get_object("episode_no_spin_button").get_value())
-    #     episode.name = builder.get_object("episode_name_entry").get_text()
-    #     episode.save()
-    #     return True
 
+    app.ui.get_object('episode_name_entry').set_text(episode.name)
+    app.ui.get_object('episode_no_spin_button').set_value(episode.number)
+    app.ui.get_object('episode_calendar').select_month(episode.date.month, episode.date.year)
+    app.ui.get_object('episode_calendar').select_day(episode.date.day)
+    app.ui.get_object('episode_players_store').clear()
+    for player in episode.players:
+        app.ui.get_object('episode_players_store').append([player.id, player.name, player.hex_id])
 
-def show_manage_players_dialog(builder: Gtk.Builder, title: str):
+    dialog = app.ui.get_object('edit_episode_dialog')  # type: Gtk.Dialog
-    """Show a dialog for managing player base data.
+    result = dialog.run()
-    :param builder: Gtk.Builder object
-    :param title: Title for the dialog
-    """
-    dialog = builder.get_object("manage_players_dialog")  # type: Gtk.Dialog
-    dialog.set_transient_for(builder.get_object("main_window"))
-    dialog.run()
     dialog.hide()
 
+    if result != Gtk.ResponseType.OK:
+        return None
 
-def show_manage_enemies_dialog(builder: Gtk.Builder, season_id: int):
+    episode.name = app.ui.get_object('episode_name_entry').get_text()
-    dialog = builder.get_object("manage_enemies_dialog")  # type: Gtk.Dialog
+    episode.number = app.ui.get_object('episode_no_spin_button').get_value()
-    dialog.set_transient_for(builder.get_object("main_window"))
+    cal_value = app.ui.get_object('episode_calendar').get_date()
-    dialog.run()
+    selected_date = datetime.datetime(*cal_value).date()
-    dialog.hide()
+    episode.date = selected_date
-
+    player_ids = [row[0] for row in app.ui.get_object('episode_players_store')]
-
+    episode.players = [app.get_by_id(app.players, player_id) for player_id in player_ids]
-def show_manage_drinks_dialog(builder: Gtk.Builder):
+    episode.season = season_id
-    dialog = builder.get_object("manage_drinks_dialog")  # type: Gtk.Dialog
+    return episode
-    dialog.set_transient_for(builder.get_object("main_window"))
-    dialog.run()
-    dialog.hide()
 
 
 def show_edit_death_dialog(builder: Gtk.Builder, episode_id: int, death):

dsst/dsst_gtk3/gtk_ui.py

@@ -75,6 +75,12 @@ class GtkUi:
             self.data_client.send_request('update_season', season)
             self.seasons.valid = False
 
+    def update_episode(self, episode: 'models.Episode'):
+        with util.network_operation(self):
+            self.data_client.send_request('update_episode', episode)
+            self.episodes.valid = False
+            self.season_stats.valid = False
+
     def update_status_bar_meta(self):
         self.ui.get_object('connection_label').set_text(self.meta.get('connection'))
         self.ui.get_object('db_label').set_text(self.meta.get('database') or '')
@@ -93,6 +99,13 @@ class GtkUi:
         (model, tree_iter) = self.ui.get_object('episodes_tree_view').get_selection().get_selected()
         return model.get_value(tree_iter, 0) if tree_iter else None
 
+    @staticmethod
+    def get_by_id(cache: 'util.Cache', object_id: int):
+        try:
+            return [x for x in cache.data if x.id == object_id][0]
+        except KeyError:
+            return None
+
 
 def main():
     if not os.path.isfile(util.CONFIG_PATH):

dsst/dsst_gtk3/handlers/base_data_handlers.py

@@ -7,7 +7,7 @@ class BaseDataHandlers:
         self.app = app
 
     def do_manage_players(self, *_):
-        dialogs.show_manage_players_dialog(self.app.ui, 'Manage Players')
+        dialogs.run_management_dialog(self.app.ui, 'manage_players_dialog')
 
     def do_add_player(self, entry):
         if entry.get_text():
@@ -16,7 +16,7 @@ class BaseDataHandlers:
             self.app.reload()
 
     def do_manage_enemies(self, *_):
-        dialogs.show_manage_enemies_dialog(self.app.ui, self.app.get_selected_season_id())
+        dialogs.run_management_dialog(self.app.ui, 'manage_enemies_dialog')
 
     def on_player_name_edited(self, _, index, value):
         row = self.app.ui.get_object('all_players_store')[index]

dsst/dsst_gtk3/handlers/dialog_handlers.py

@@ -9,6 +9,11 @@ class DialogHandlers:
     def __init__(self, app: 'gtk_ui.GtkUi'):
         self.app = app
 
+    @staticmethod
+    def do_run_manage_dialog(dialog: 'Gtk.Dialog'):
+        dialog.run()
+        dialog.hide()
+
     def do_add_player_to_episode(self, combo):
         """ Signal Handler for Add Player to Episode Button in Manage Episode Dialog
         :param combo: Combo box with all the available players
@@ -16,10 +21,10 @@ class DialogHandlers:
         player_id = util.get_combo_value(combo, 0)
         if player_id:
             self.app.ui.get_object('add_player_combo_box').set_active(-1)
-            # player = sql.Player.get(sql.Player.id == player_id)
+            player = self.app.get_by_id(self.app.players, player_id)
             store = self.app.ui.get_object('episode_players_store')
-            # if not any(row[0] == player_id for row in store):
+            if not any(row[0] == player_id for row in store):
-            #     store.append([player_id, player.name, player.hex_id])
+                store.append([player_id, player.name, player.hex_id])
 
     def do_add_enemy(self, entry):
         if entry.get_text():
@@ -28,9 +33,6 @@ class DialogHandlers:
             # store.append([enemy.name, False, 0, enemy.id])
             entry.set_text('')
 
-    def do_manage_drinks(self, *_):
-        result = dialogs.show_manage_drinks_dialog(self.app.ui)
-
     def do_show_date_picker(self, entry: 'Gtk.Entry', *_):
         dialog = self.app.ui.get_object('date_picker_dialog')
         result = dialog.run()

dsst/dsst_gtk3/handlers/season_handlers.py

@@ -21,8 +21,10 @@ class SeasonHandlers:
         season_id = self.app.get_selected_season_id()
         if not season_id:
             return
-        dialogs.show_episode_dialog(self.app.ui, 'Create new Episode', season_id)
+        ep = dialogs.edit_episode(self.app, season_id)
-        self.app.reload()
+        if ep:
+            self.app.update_episode(ep)
+            self.app.reload()
 
     def on_selected_episode_changed(self, *_):
         reload.reload_episode_stats(self.app)

dsst/dsst_server/func_write.py

@@ -18,3 +18,19 @@ class WriteFunctions:
                     sql.Season.start_date: season.start_date,
                     sql.Season.end_date: season.end_date})
          .execute())
+
+    @staticmethod
+    def update_episode(episode: 'models.Episode', *_):
+        players = list(sql.Player.select().where(sql.Player.id << [player.id for player in episode.players]))
+        new_ep_id = (sql.Episode
+                     .insert(id=episode.id, number=episode.number, seq_number=episode.number, name=episode.name,
+                             date=episode.date, season=episode.season)
+                     .on_conflict(update={sql.Episode.name: episode.name,
+                                          sql.Episode.seq_number: episode.seq_number,
+                                          sql.Episode.number: episode.number,
+                                          sql.Episode.date: episode.date,
+                                          sql.Episode.season: episode.season})
+                     .execute())
+        db_episode = sql.Episode.get(sql.Episode.id == new_ep_id)
+        db_episode.players = players
+        db_episode.save()