Mob team synchronized via MQTT.

DeadlyApps · DeadlyApps · commit c584f0b6fa91 · 2016-02-26T08:06:58.000-08:00
diff --git a/Frames/MobTimerController.py b/Frames/MobTimerController.py
@@ -33,8 +33,8 @@ def __init__(self, *args, **kwargs):
         self.timer_extension_count = self.settings_manager.get_timer_extension_count()
         self.extensions_used = 0
         atexit.register(self.session_manager.clear_sessions)
-        if self.session_manager.get_active_sessions().__len__() > 0:
-            self.quit_and_destroy_session()
+        # if self.session_manager.get_active_sessions().__len__() > 0:
+        #     self.quit_and_destroy_session()
 
         self.session_manager.create_session()
         self.iconbitmap(default='time-bomb.ico')
@@ -83,7 +83,7 @@ def __init__(self, *args, **kwargs):
         self.dojo_manager = DojoManager(self)
 
 
-    def launch_transparent_countdown_if_blocking(self, event):
+    def launch_transparent_countdown_if_blocking(self, event = None):
         if self.frame_is_screen_blocking():
             self.show_transparent_countdown_frame()
 
@@ -160,6 +160,7 @@ def remove_title_bar(self):
             container.master.overrideredirect(1)
 
     def set_always_on_top(self):
+        return
         for container in self.containers:
             container.master.wm_attributes("-topmost", True)
             if PlatformUtility.platform_is_mac():
@@ -169,6 +170,7 @@ def set_always_on_top(self):
             container.master.focus_force()
 
     def set_full_screen_always_on_top(self):
+        return
         self.set_always_on_top()
         self.remove_title_bar()
         self.disable_resizing()
diff --git a/Frames/ScreenBlockerFrame.py b/Frames/ScreenBlockerFrame.py
@@ -47,7 +47,7 @@ def mobber_list_change_callback(self, mobber_list, driver_index, navigator_index
 
             self.names_list.insert('', END, text=name, tags=tags)
 
-    def time_change_callback(self, time, minutes, seconds):
+    def time_change_callback(self, time, minutes, seconds, origin_station_name=None):
         self.label_minutes['text'] = "{0:0>2}".format(minutes)
         self.label_seconds['text'] = "{0:0>2}".format(seconds)
 
@@ -203,11 +203,9 @@ def remove_mobber_if_screen_blocking(self, event):
     def add_default_team(self, event):
         team = self.settings_manager.get_general_team().split(',')
         randomize_team = self.settings_manager.get_randomize_team()
-        self.mobber_manager.clear()
         if randomize_team:
             random.shuffle(team)
-        for member in team:
-            self.mobber_manager.add_mobber(member)
+        self.mobber_manager.set_mobber_list(team)
 
     def focus_mobber_entry(self):
         self.add_mobber_entry.focus_set()
diff --git a/Infrastructure/DojoManager.py b/Infrastructure/DojoManager.py
@@ -1,45 +1,62 @@
 import _thread
 import random
+import uuid
 
 import paho.mqtt.publish as mqtt_pub
 import paho.mqtt.client as mqtt
 import json
 
-RANDOM_TOPIC_BID = "RandomTopicBid"
-
-START_RANDOM_DRIVER_BID = "StartRandomDriverBid"
-
 MOBBER_LIST = "MobberList"
 
 TIME_CHANGE = "TimeChange"
 
+SAY_HELLO = "SayHello"
+
+START_TIMER = "StartTimer"
+
 
 class DojoManager(object):
     def __init__(self, controller):
         if not controller.settings_manager.get_dojo_enabled():
             return
+
+        self.time_change_increment = 0
+        self.mobber_change_increment = 0
+        self.session_id = uuid.uuid4().__str__()
+
+
         self.switch_dictionary = {
             MOBBER_LIST: self.sub_mobber_list,
             TIME_CHANGE: self.sub_time_change,
-            START_RANDOM_DRIVER_BID: self.sub_start_random_driver_bid,
-            RANDOM_TOPIC_BID: self.sub_random_topic_bid
+            SAY_HELLO: self.sub_say_hello,
+            START_TIMER: self.sub_start_timer,
         }
         self.station_drivers = {}
+        self.other_stations = []
         self.controller = controller
         self.dojo_broker = self.controller.settings_manager.get_dojo_broker()
         self.dojo_port = self.controller.settings_manager.get_dojo_port()
-        self.dojo_mob_station_name = self.controller.settings_manager.get_dojo_mob_station_name()
+        self.dojo_mob_station_name = self.controller.settings_manager.get_dojo_mob_station_name() + uuid.uuid4().__str__()
         self.dojo_session_id = self.controller.settings_manager.get_dojo_session_id()
         self.dojo_topic_root = self.controller.settings_manager.get_dojo_topic_root()
         self.controller.mobber_manager.subscribe_to_mobber_list_change(self.publish_mobber_list_changes)
         self.controller.time_options_manager.subscribe_to_timechange(self.publish_time_change)
         self.subscribe_to_time_change()
+        self.say_hello()
+
+    def say_hello(self):
+        topic = self.generate_topic(SAY_HELLO)
+        self.publish(topic, "")
 
-    def publish_time_change(self, time_string, minutes, seconds):
+    def publish_time_change(self, time_string, minutes, seconds, origin_station_name=None):
         topic = self.generate_topic(TIME_CHANGE)
+        station_name = self.dojo_mob_station_name
+        if origin_station_name is not None:
+            return
         payload_dictionary = {
             "minutes": minutes,
-            "seconds": seconds
+            "seconds": seconds,
+            "station_name": station_name
         }
         payload = json.dumps(payload_dictionary)
         self.publish(topic, payload)
@@ -73,6 +90,7 @@ def on_message(self, client, userdata, msg):
         session_id = topic_parts[1]
         station_name = topic_parts[2]
         message_type = topic_parts[3]
+        print("on_message",msg.topic)
         self.switch_statement_dictionary_trick(station_name, message_type, msg.payload)
 
     def switch_statement_dictionary_trick(self, station_name, message_type, payload):
@@ -81,43 +99,42 @@ def switch_statement_dictionary_trick(self, station_name, message_type, payload)
     def sub_mobber_list(self, station_name, message_type, payload):
         if not station_name == self.dojo_mob_station_name:
             payload_dictionary = json.loads(payload.decode("utf-8"))
-            for mobber in payload_dictionary["mobber_list"]:
-                self.controller.mobber_manager.add_mobber(mobber)
-        topic = self.generate_topic(START_RANDOM_DRIVER_BID)
-        self.publish(topic, "")
+            mobber_list = payload_dictionary["mobber_list"]
+            print("sub_mobber_list",mobber_list)
+            self.controller.mobber_manager.set_mobber_list(mobber_list)
 
     def generate_topic(self, message_type):
         topic = "{}/{}/{}/{}".format(self.dojo_topic_root, self.dojo_session_id, self.dojo_mob_station_name,
                                      message_type)
+        print("generate_topic",topic)
         return topic
 
     def sub_time_change(self, station_name, message_type, payload):
+        print(payload)
         if not station_name == self.dojo_mob_station_name:
             payload_dictionary = json.loads(payload.decode("utf-8"))
             minutes = payload_dictionary["minutes"]
             seconds = payload_dictionary["seconds"]
+            origin_station_name = payload_dictionary["station_name"]
             if not (
                             self.controller.time_options_manager.minutes == minutes and self.controller.time_options_manager.seconds == seconds):
-                self.controller.time_options_manager.set_countdown_time(minutes, seconds)
+                self.controller.time_options_manager.set_countdown_time(minutes, seconds, origin_station_name)
 
-    def sub_start_random_driver_bid(self, station_name, message_type, payload):
-        print(message_type)
-        # topic = self.generate_topic(RANDOM_TOPIC_BID)
-        # if self.controller.mobber_manager.mobber_list.__len__() > 1:
-        #     payload_dictionary = {"bid": random.randint(0, 100),
-        #                           "mobber": random.choice(self.controller.mobber_manager.mobber_list)}
-        #     self.publish(topic, json.dumps(payload_dictionary))
+    def sub_say_hello(self, station_name, message_type, payload):
+        if not station_name == self.dojo_mob_station_name:
+            if not self.other_stations.__contains__(station_name):
+                self.other_stations.append(station_name)
+                topic = self.generate_topic(SAY_HELLO)
+                self.publish(topic, "")
 
-    def sub_random_topic_bid(self, station_name, message_type, payload):
-        print(payload)
-        # payload_dictionary = json.loads(payload.decode("utf-8"))
-        # self.station_drivers[payload_dictionary["mobber"]] = station_name
-        # print(self.station_drivers)
-        # self.controller.mobber_manager.fire_time_change_callbacks()
+    def sub_start_timer(self, station_name, message_type, payload):
+        if not station_name == self.dojo_mob_station_name:
+            self.controller.launch_transparent_countdown_if_blocking()
 
     def subscribe_to_dojo(self):
         client = mqtt.Client()
         client.on_connect = self.on_connect
         client.on_message = self.on_message
         client.connect(self.dojo_broker, self.dojo_port, 60)
         client.loop_forever()
+
diff --git a/Infrastructure/MobberManager.py b/Infrastructure/MobberManager.py
@@ -16,43 +16,44 @@ def add_mobber(self, mobber_name):
         clean_mobber_name = str(mobber_name).strip()
         if clean_mobber_name != "" and not self.mobber_list.__contains__(clean_mobber_name):
             self.mobber_list.append(mobber_name)
-            self.fire_time_change_callbacks()
+            self.fire_mobber_list_change_callbacks()
 
     def get_mobbers(self):
         return self.mobber_list
 
     def remove_mobber(self, remove_mobber_index):
-        if self.mobber_count() == 0: return
+        if self.mobber_count() == 0:
+            return
         del self.mobber_list[remove_mobber_index]
-        self.fire_time_change_callbacks()
+        self.fire_mobber_list_change_callbacks()
 
     def move_mobber_up(self, swap_index):
         if self.mobber_count() == 0: return
         destination_index = swap_index - 1
         self.mobber_list[swap_index], self.mobber_list[destination_index] = self.mobber_list[destination_index], \
                                                                             self.mobber_list[swap_index]
-        self.fire_time_change_callbacks()
+        self.fire_mobber_list_change_callbacks()
 
     def move_mobber_down(self, swap_index):
         if self.mobber_count() == 0: return
         destination_index = (swap_index + 1) % self.mobber_list.__len__()
         self.mobber_list[swap_index], self.mobber_list[destination_index] = self.mobber_list[destination_index], \
                                                                             self.mobber_list[swap_index]
-        self.fire_time_change_callbacks()
+        self.fire_mobber_list_change_callbacks()
 
     def subscribe_to_mobber_list_change(self, mobber_list_change_callback):
         self.mobber_list_change_callbacks.append(mobber_list_change_callback)
-        self.fire_time_change_callbacks()
+        self.fire_mobber_list_change_callbacks()
 
-    def fire_time_change_callbacks(self):
+    def fire_mobber_list_change_callbacks(self):
         self.update_next_driver_index()
         for mobber_list_change_callback in self.mobber_list_change_callbacks:
             if mobber_list_change_callback:
                 mobber_list_change_callback(self.mobber_list, self.driver_index, self.next_driver_index)
 
     def clear(self):
         self.mobber_list = []
-        self.fire_time_change_callbacks()
+        self.fire_mobber_list_change_callbacks()
 
     def switch_next_driver(self):
         mobber_count = self.mobber_list.__len__()
@@ -61,7 +62,7 @@ def switch_next_driver(self):
                 self.driver_index = self.next_driver_index
             else:
                 self.driver_index = (self.driver_index + 1) % mobber_count
-        self.fire_time_change_callbacks()
+        self.fire_mobber_list_change_callbacks()
 
     def update_next_driver_index(self):
         mobber_count = self.mobber_list.__len__()
@@ -84,5 +85,14 @@ def rewind_driver(self):
             if self.driver_index < 0:
                 self.driver_index = mobber_count - 1
         self.update_next_driver_index()
-        self.fire_time_change_callbacks()
+        self.fire_mobber_list_change_callbacks()
+
+    def set_mobber_list(self, mobber_list):
+        if self.mobber_list != mobber_list:
+            self.mobber_list = []
+            for mobber_name in mobber_list:
+                clean_mobber_name = str(mobber_name).strip()
+                if clean_mobber_name != "" and not self.mobber_list.__contains__(clean_mobber_name):
+                    self.mobber_list.append(mobber_name)
+            self.fire_mobber_list_change_callbacks()
 
diff --git a/Infrastructure/TimeSettingsManager.py b/Infrastructure/TimeSettingsManager.py
@@ -29,12 +29,12 @@ def subscribe_to_timechange(self, time_change_callback):
         self.time_change_callbacks.append(time_change_callback)
         self.fire_time_change_callbacks()
 
-    def fire_time_change_callbacks(self):
+    def fire_time_change_callbacks(self, origin_station_name=None):
         for time_change_callback in self.time_change_callbacks:
             if time_change_callback:
-                time_change_callback(self.get_time_string(), self.minutes, self.seconds)
+                time_change_callback(self.get_time_string(), self.minutes, self.seconds, origin_station_name)
 
-    def set_countdown_time(self, minutes, seconds):
+    def set_countdown_time(self, minutes, seconds, origin_station_name=None):
         self.minutes = minutes
         self.seconds = seconds
-        self.fire_time_change_callbacks()
+        self.fire_time_change_callbacks(origin_station_name)
diff --git a/MobTimer.cfg b/MobTimer.cfg
@@ -33,7 +33,7 @@ extension count = 1
 
 [CODE DOJO]
 enable dojo mode = True
-broker = iot.eclipse.org
+broker = localhost
 port = 1883
 mob station name = NewName
 session id = 1337
diff --git a/tests/Infrastructure/MobberManager/TestsMobberManager.py b/tests/Infrastructure/MobberManager/TestsMobberManager.py
@@ -30,7 +30,7 @@ def test_add_mobber_joe_chris_joe__remove_joe_has_joe_chris(self):
         mobber_manager = MobberManager()
         mobber_manager.add_mobber("Joe")
         mobber_manager.add_mobber("Chris")
-        mobber_manager.add_mobber("Joe")
+        mobber_manager.add_mobber("John")
         mobber_manager.remove_mobber(2)
         result = ["Joe", "Chris"]
         self.assertEqual(mobber_manager.get_mobbers(), result)
@@ -178,6 +178,7 @@ def time_change_callback(mobber_list, driver_index, navigator_index):
         mobber_manager.switch_next_driver()
         mobber_manager.switch_next_driver()
         mobber_manager.switch_next_driver()
+        mobber_manager.set_mobber_list(["Hello", "Eric", "Joe"])
         mobber_manager.switch_next_driver()
         mobber_manager.switch_next_driver()
         mobber_manager.remove_mobber(2)
diff --git a/tests/Infrastructure/MobberManager/tests.Infrastructure.MobberManager.TestsMobberManager.test_subscribe_to_mobber_list_changes_random.approved.txt b/tests/Infrastructure/MobberManager/tests.Infrastructure.MobberManager.TestsMobberManager.test_subscribe_to_mobber_list_changes_random.approved.txt
@@ -9,15 +9,16 @@ Action 7:Joe, Chris (Next), Sam, John (Driver), Bill,
 Action 8:Joe, Chris (Driver), Sam (Next), John, Bill, 
 Action 9:Joe, Chris, Sam (Driver), John (Next), Bill, 
 Action 10:Joe, Chris (Next), Sam, John (Driver), Bill, 
-Action 11:Joe, Chris (Driver), Sam (Next), John, Bill, 
-Action 12:Joe, Chris, Sam (Driver), John, Bill (Next), 
-Action 13:Joe, Chris (Next), John (Driver), Bill, 
-Action 14:Chris, John (Next), Bill (Driver), 
-Action 15:Chris (Next), John (Driver), Bill, 
-Action 16:Chris, John (Driver), Bill, Seth (Next), 
-Action 17:John, Chris (Driver), Bill, Seth (Next), 
-Action 18:John, Chris (Driver), Bill, Seth, Fredrick (Next), 
-Action 19:John, Bill (Driver), Chris, Seth, Fredrick (Next), 
-Action 20:John, Chris (Driver), Seth (Next), Fredrick, 
-Action 21:Chris, Seth (Driver), Fredrick (Next), 
-Action 22:Seth (Next), Fredrick (Driver), 
+Action 11:Hello, Eric (Next), Joe, 
+Action 12:Hello, Eric (Driver), Joe (Next), 
+Action 13:Hello, Eric (Next), Joe (Driver), 
+Action 14:Hello (Driver), Eric (Next), 
+Action 15:Eric (Driver) (Next), 
+Action 16:Eric (Driver) (Next), 
+Action 17:Eric (Driver), Seth (Next), 
+Action 18:Seth (Driver), Eric (Next), 
+Action 19:Seth (Driver), Eric, Fredrick (Next), 
+Action 20:Seth (Driver), Fredrick (Next), Eric, 
+Action 21:Seth (Driver), Eric (Next), 
+Action 22:Eric (Driver) (Next), 
+Action 23:
diff --git a/tests/Infrastructure/TimeOptionsManager/TestsTimeOptionsManager.py b/tests/Infrastructure/TimeOptionsManager/TestsTimeOptionsManager.py
@@ -58,7 +58,7 @@ def test_subscribe_to_time_changes(self):
         time_options_manager = TimeSettingsManager()
         result = {"result": "time"}
 
-        def time_change_callback(time, minutes, seconds):
+        def time_change_callback(time, minutes, seconds,origin_station_name):
             result["result"] += " " + time
 
         time_options_manager.subscribe_to_timechange(time_change_callback)
@@ -71,7 +71,7 @@ def test_subscribe_to_time_changes_complex(self):
         time_options_manager = TimeSettingsManager()
         result = {"result": "Time Options after Change:", "increment" : 0}
 
-        def time_change_callback(time, minutes, seconds):
+        def time_change_callback(time, minutes, seconds,origin_station_name):
             result["increment"] += 1
             result["result"] += "\n Change " + result["increment"].__str__() + "| " + time
 
