Adding points check and fixing some minor other issues

src/main/database_module/database_classes/db_classes.py

@@ -1,11 +1,8 @@
 from sqlalchemy import Column, String, Integer, ForeignKey, Date
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import relationship
 
-from src.main.db_session import DatabaseSession
-
 Base = declarative_base()
 
 class Play(Base):
@@ -14,6 +11,7 @@ class Play(Base):
     play_id = Column(String, nullable=False, primary_key=True)
     pitch_value = Column(Integer, nullable=True)
     creation_date = Column(Date, nullable=False)
+    server_id = Column(String, nullable=False)
 
     guesses = relationship(lambda : Guess)
 

src/main/database_module/guess_dao.py

@@ -3,6 +3,7 @@ from copy import deepcopy
 from src.main.database_module.database_classes.db_classes import Guess
 from src.main.db_session import DatabaseSession
 
+
 MEMBER_ID = 'member_id'
 PLAY_ID = 'play_id'
 GUESSED_NUMBER = 'guessed_number'
@@ -15,11 +16,13 @@ class GuessDAO():
     Session = None
     engine = None
 
+    _database_session = None
+
     def __init__(self):
-        pass
+        self._database_session = DatabaseSession()
 
     def insert(self, guess_info):
-        session = DatabaseSession.session
+        session = self._database_session.get_or_create_session()
 
         guess = Guess(
             member_id=guess_info[MEMBER_ID],
@@ -55,7 +58,7 @@ class GuessDAO():
         return converted_games
 
     def set_differences(self, pitch_value, play_id):
-        session = DatabaseSession.session
+        session = self._database_session.get_or_create_session()
         games_to_update = self.__convert_all__(session.query(Guess).filter(Guess.play_id == play_id))
 
         for game in games_to_update:
@@ -74,7 +77,7 @@ class GuessDAO():
             return possible_value
 
     def fetch_closest(self, num_to_fetch):
-        session = DatabaseSession.session
+        session = self._database_session.get_or_create_session()
 
         return self.__convert_all__(
             session\
@@ -83,8 +86,19 @@ class GuessDAO():
                 .limit(num_to_fetch)
         )
 
+    def refresh(self):
+        self._database_session.__create_new_session__() # I know, I know.  It's fine.
+
+    def get_all_guesses_for_plays(self, play_ids):
+        session = self._database_session.get_or_create_session()
+        return self.__convert_all__(
+            session
+                .query(Guess)
+                .filter(Guess.play_id.in_(play_ids))
+        )
+
     def get_closest_on_play(self, play):
-        session = DatabaseSession.session
+        session = self._database_session.get_or_create_session()
 
         # TODO: Make this a MAX query for ties
         converted_guesses = self.__convert_all__(

src/main/database_module/play_dao.py

@@ -1,46 +1,62 @@
 from copy import deepcopy
+from sqlalchemy.sql.expression import and_
 
 from src.main.db_session import DatabaseSession
 from src.main.database_module.database_classes.db_classes import Play
 
+import datetime
+
 PLAY_ID = 'play_id'
 PITCH_VALUE = 'pitch_value'
 CREATION_DATE = 'creation_date'
+SERVER_ID = 'server_id'
 
 class PlayDAO():
     db_string = None
     session = None
     Session = None
     engine = None
+    _database_session = None
 
     def __init__(self):
-        pass
+        self._database_session = DatabaseSession()
 
     def insert(self, play_info):
-        session = DatabaseSession.session
+        session = self._database_session.get_or_create_session()
 
         play = Play(
             play_id = play_info[PLAY_ID],
             pitch_value = play_info[PITCH_VALUE] if PITCH_VALUE in play_info else None,
-            creation_date = play_info[CREATION_DATE]
+            creation_date = play_info[CREATION_DATE],
+            server_id = play_info[SERVER_ID]
         )
 
         session.add(play)
         session.commit()
 
     def get_play_by_id(self, input_id):
-        session = DatabaseSession.session
+        session = self._database_session.get_or_create_session()
         return self.__convert_all__(session.query(Play).filter(Play.play_id == input_id))
 
+    def get_all_plays_after(self, timestamp, input_server_id):
+        session = self._database_session.get_or_create_session()
+        return self.__convert_all__(session.query(Play).filter(and_(Play.server_id == str(input_server_id), Play.creation_date > timestamp)))
+
+    def get_all_plays_on_server(self, input_server_id, earliest_timestamp):
+        session = self._database_session.get_or_create_session()
+        converted_datetime = datetime.datetime.fromtimestamp(earliest_timestamp / 1000.0)
+
+        return self.__convert_all__(session.query(Play).filter(and_(Play.server_id == str(input_server_id), Play.creation_date > converted_datetime)))
+
     '''
         Checks to see if there is a play that is currently active or not
     '''
-    def is_active_play(self):
-        return self.get_active_play() != None
+    def is_active_play(self, server_id):
+        return self.get_active_play(server_id) != None
 
-    def get_active_play(self):
-        session = DatabaseSession.session
-        plays = self.__convert_all__(session.query(Play).filter(Play.pitch_value == None))
+    def get_active_play(self, input_server_id):
+        session = self._database_session.get_or_create_session()
+        plays = self.__convert_all__(session.query(Play).filter(and_(Play.pitch_value == None, Play.server_id == str(input_server_id))))
 
         if len(plays) > 1:
             raise AssertionError("More than one active play!  Can't continue!")
@@ -49,18 +65,21 @@ class PlayDAO():
         else:
             return plays[0]
 
-    def resolve_play(self, input_pitch):
-        session = DatabaseSession.session
-        active_id = self.get_active_play()
+    def resolve_play(self, input_pitch, input_server_id):
+        session = self._database_session.get_or_create_session()
+        active_id = self.get_active_play(input_server_id)
 
         session\
             .query(Play)\
-            .filter(Play.pitch_value == None)\
+            .filter(and_(Play.pitch_value == None, Play.server_id == str(input_server_id)))\
             .update({Play.pitch_value: input_pitch})
         session.commit()
 
         return active_id
 
+    def refresh(self):
+        self._database_session.__create_new_session__() # I know, I know.  It's fine.
+
     '''
        Converts the database object into a Dictionary, so that the database object is not passed out of the
        datastore layer.