Implementing Random Driver Bidding

Author: DeadlyApps

Frames/MobTimerController.py

@@ -8,6 +8,7 @@
 from Frames.ScreenBlockerFrame import ScreenBlockerFrame
 from Frames.TransparentCountdownFrame import TransparentCountdownFrame
 from Infrastructure.CountdownManager import CountdownManager
+from Infrastructure.DojoManager import DojoManager
 from Infrastructure.MobberManager import MobberManager
 from Infrastructure.PlatformUtility import PlatformUtility
 from Infrastructure.ScreenUtility import ScreenUtility
@@ -79,6 +80,9 @@ def __init__(self, *args, **kwargs):
         self.bind_all("<Control-Return>", self.launch_transparent_countdown_if_blocking)
         self.time_options_manager.set_countdown_time(self.settings_manager.get_timer_minutes(), self.settings_manager.get_timer_seconds())
 
+        self.dojo_manager = DojoManager(self)
+
+
     def launch_transparent_countdown_if_blocking(self, event):
         if self.frame_is_screen_blocking():
             self.show_transparent_countdown_frame()

Frames/ScreenBlockerFrame.py

@@ -35,11 +35,15 @@ def mobber_list_change_callback(self, mobber_list, driver_index, navigator_index
         for index in range(0, mobber_list.__len__()):
             tags = ()
             name = mobber_list[index]
-            if index == driver_index:
-                tags = (TAGNAME_CURRENT_MOBBER)
-                name += " <= Current"
-            if index == navigator_index:
-                name += " <= Next"
+            if self.controller.settings_manager.get_dojo_enabled:
+                if self.controller.dojo_manager.station_drivers.__contains__(name):
+                    name += " <= {}".format(self.controller.dojo_manager.station_drivers[name])
+            else:
+                if index == driver_index:
+                    tags = (TAGNAME_CURRENT_MOBBER)
+                    name += " <= Current"
+                if index == navigator_index:
+                    name += " <= Next"
 
             self.names_list.insert('', END, text=name, tags=tags)
 

Infrastructure/DojoManager.py

@@ -0,0 +1,123 @@
+import _thread
+import random
+
+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"
+
+
+class DojoManager(object):
+    def __init__(self, controller):
+        if not controller.settings_manager.get_dojo_enabled():
+            return
+        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
+        }
+        self.station_drivers = {}
+        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_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()
+
+    def publish_time_change(self, time_string, minutes, seconds):
+        topic = self.generate_topic(TIME_CHANGE)
+        payload_dictionary = {
+            "minutes": minutes,
+            "seconds": seconds
+        }
+        payload = json.dumps(payload_dictionary)
+        self.publish(topic, payload)
+
+    def publish_mobber_list_changes(self, mobber_list, driver_index, next_driver_index):
+        topic = self.generate_topic(MOBBER_LIST)
+        payload_object = {
+            "driver_index": driver_index,
+            "next_driver_index": next_driver_index,
+            "mobber_list": mobber_list
+        }
+        payload = json.dumps(payload_object)
+        self.publish(topic, payload)
+
+    def publish(self, topic, payload):
+        _thread.start_new_thread(self.thread_publish, (topic, payload))
+
+    def thread_publish(self, topic, payload):
+        mqtt_pub.single(topic, hostname=self.dojo_broker, port=self.dojo_port, payload=payload)
+
+    def subscribe_to_time_change(self):
+        _thread.start_new_thread(self.subscribe_to_dojo, ())
+
+    def on_connect(self, client, userdata, flags, rc):
+        topic = "{}/{}/#".format(self.dojo_topic_root, self.dojo_session_id)
+        client.subscribe(topic)
+
+    def on_message(self, client, userdata, msg):
+        topic_parts = msg.topic.split('/')
+        topic_root = topic_parts[0]
+        session_id = topic_parts[1]
+        station_name = topic_parts[2]
+        message_type = topic_parts[3]
+        self.switch_statement_dictionary_trick(station_name, message_type, msg.payload)
+
+    def switch_statement_dictionary_trick(self, station_name, message_type, payload):
+        self.switch_dictionary[message_type](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, "")
+
+    def generate_topic(self, message_type):
+        topic = "{}/{}/{}/{}".format(self.dojo_topic_root, self.dojo_session_id, self.dojo_mob_station_name,
+                                     message_type)
+        return topic
+
+    def sub_time_change(self, station_name, message_type, 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"]
+            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)
+
+    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_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 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()

Infrastructure/MobberManager.py

@@ -13,7 +13,8 @@ def mobber_count(self):
         return self.mobber_list.__len__()
 
     def add_mobber(self, mobber_name):
-        if str(mobber_name).strip() != "":
+        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()
 
@@ -84,3 +85,4 @@ def rewind_driver(self):
                 self.driver_index = mobber_count - 1
         self.update_next_driver_index()
         self.fire_time_change_callbacks()
+

Infrastructure/SettingsManager.py

@@ -7,6 +7,7 @@ class SettingsManager(object):
     TIMER_SETTINGS = "TIMER SETTINGS"
     CONTINUE_SCREEN_BLOCKER_SETTINGS = "CONTINUE SCREEN BLOCKER SETTINGS"
     SCREEN_BLOCKER_SETTINGS = "SCREEN BLOCKER SETTINGS"
+    CODE_DOJO = "CODE DOJO"
 
     def __init__(self):
         self.config = configparser.ConfigParser()
@@ -16,6 +17,7 @@ def __init__(self):
         self.screen_blocker_settings = self.config[SettingsManager.SCREEN_BLOCKER_SETTINGS]
         self.general_settings_ = self.config[SettingsManager.GENERAL_SETTINGS]
         self.timer_settings_ = self.config[SettingsManager.TIMER_SETTINGS]
+        self.code_dojo = self.config[SettingsManager.CODE_DOJO]
 
     def get_transparent_window_screen_size_percent(self):
         return self.window_settings_.getfloat("size percentage", 0.3)
@@ -84,4 +86,22 @@ def get_timer_extension_count(self):
         return self.timer_settings_.getint("extension count", 2)
 
     def get_general_enable_tips(self):
-        return self.general_settings_.getboolean("enable tips", True)
+        return self.general_settings_.getboolean("enable tips", True)
+
+    def get_dojo_enabled(self):
+        return self.code_dojo.getboolean("enable dojo mode", False)
+
+    def get_dojo_broker(self):
+        return self.code_dojo.get("broker", "iot.eclipse.org")
+
+    def get_dojo_port(self):
+        return self.code_dojo.getint("port", 1883)
+
+    def get_dojo_mob_station_name(self):
+        return self.code_dojo.get("mob station name", "NewName")
+
+    def get_dojo_session_id(self):
+        return self.code_dojo.get("session id","1337")
+
+    def get_dojo_topic_root(self):
+        return self.code_dojo.get("topic root", "MobTimer")

MobTimer.cfg

@@ -23,11 +23,18 @@ use logo image = False
 logo image name = company-logo.png
 auto theme logo = False
 
-
 [TIMER SETTINGS]
 minutes = 5
 seconds = 0
 extension enabled = False
 extension minutes = 0
 extension seconds = 30
-extension count = 1
+extension count = 1
+
+[CODE DOJO]
+enable dojo mode = True
+broker = iot.eclipse.org
+port = 1883
+mob station name = NewName
+session id = 1337
+topic root = MobTimer

MobTimer.py

@@ -2,3 +2,9 @@
 
 root = MobTimerController()
 root.mainloop()
+
+
+
+
+
+