Feat: User Relationships and Session Members.

datastores/datastore_base.py

@@ -59,7 +59,7 @@ class DataStore_Base(BaseModel):
                 proc_string += f'{"" if i == 0 else ", "}{param_name} := {param_expr}'
         proc_string += ')'
         stmt = text(proc_string)
-        Helper_App.console_log(f'{_m}\nproc_string: {stmt}\nargs: {argument_dict_list}')
+        # Helper_App.console_log(f'{_m}\nproc_string: {stmt}\nargs: {argument_dict_list}')
 
         rows = []
         with db.engine.connect().execution_options(isolation_level="AUTOCOMMIT") as conn:
@@ -70,7 +70,7 @@ class DataStore_Base(BaseModel):
             # Fetch all rows as mappings before connection closes
             if result.returns_rows:
                 rows = result.mappings().fetchall()
-            Helper_App.console_log(f'result: {rows}')
+            # Helper_App.console_log(f'result: {rows}')
         return rows
 
     # Map SQLAlchemy types to PostgreSQL type names for CAST()
@@ -108,49 +108,49 @@ class DataStore_Base(BaseModel):
         func_string += ')'
         stmt = text(func_string)
 
-        Helper_App.console_log(f'{_m}\nfunc_string: {stmt}\nargs: {argument_dict_list}')
+        # Helper_App.console_log(f'{_m}\nfunc_string: {stmt}\nargs: {argument_dict_list}')
 
         if has_arguments:
             result = db.session.execute(stmt, argument_dict_list)
         else:
             result = db.session.execute(stmt)
-        Helper_App.console_log(f'result: {result}')
+        # Helper_App.console_log(f'result: {result}')
         return result
     
     @staticmethod
     def db_cursor_clear(cursor):
         while cursor.nextset():
-            Helper_App.console_log(f'unexpected result set: {cursor.fetchall()}')
+            Helper_App.console_log(f'db_cursor_clear\nunexpected result set: {cursor.fetchall()}')
 
     @staticmethod
     def get_user_session():
-        Helper_App.console_log('DataStore_Base.get_user_session')
+        # Helper_App.console_log('DataStore_Base.get_user_session')
         user = User.from_json(session.get(User.FLAG_USER))
         """
         if user.user_id <= 0:
             user.user_id = 3
         """
-        Helper_App.console_log(f'User: {user}')
+        # Helper_App.console_log(f'User: {user}')
         return user
     
     @staticmethod
     def upload_bulk(permanent_table_name, records, batch_size):
         _m = 'DataStore_Base.upload_bulk'
-        Helper_App.console_log(f'{_m}\nstarting...')
-        Helper_App.console_log(f'permanent_table_name: {permanent_table_name}')
+        # Helper_App.console_log(f'{_m}\nstarting...')
+        # Helper_App.console_log(f'permanent_table_name: {permanent_table_name}')
         if db.session.dirty or db.session.new or db.session.deleted:
-            Helper_App.console_log("Session is not clean")
+            # Helper_App.console_log("Session is not clean")
             return
         # Assuming `permanent_table_name` is a string representing the table name
         table_object = db.metadata.tables.get(permanent_table_name)
-        Helper_App.console_log(f'Tables: {list(db.metadata.tables.keys())}')
+        # Helper_App.console_log(f'Tables: {list(db.metadata.tables.keys())}')
         if table_object is None:
-            Helper_App.console_log(f"Table {permanent_table_name} not found in metadata.")
+            # Helper_App.console_log(f"Table {permanent_table_name} not found in metadata.")
             return
-        else:
-            expected_columns = set(column.name for column in db.inspect(table_object).columns)
-            Helper_App.console_log(f'table name: {table_object.name}')
-            Helper_App.console_log(f'expected_columns: {expected_columns}')
+        # else:
+            # expected_columns = set(column.name for column in db.inspect(table_object).columns)
+            # Helper_App.console_log(f'table name: {table_object.name}')
+            # Helper_App.console_log(f'expected_columns: {expected_columns}')
         max_retries = 3
         initial_backoff = 1
         for i in range(0, len(records), batch_size):
@@ -180,7 +180,7 @@ class DataStore_Base(BaseModel):
             except Exception as e:
                 db.session.rollback()
                 raise e
-        Helper_App.console_log(f'Records uploaded in batches.')
+        # Helper_App.console_log(f'Records uploaded in batches.')
 
     @classmethod
     def get_many_error(cls, guid):
@@ -189,23 +189,23 @@ class DataStore_Base(BaseModel):
         arguments = Parameters_SQL_Error.get_default(guid)
         argument_dict = arguments.to_json()
         argument_types = Parameters_SQL_Error.get_type_hints()
-        Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
+        # Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
         
         errors = []
         try:
             error_result = cls.db_function_execute('tcg.public.FN_Error_Get_Many', argument_dict, argument_types)
             error_result_set = error_result.fetchall()
-            Helper_App.console_log(f'raw errors: {error_result_set}')
+            # Helper_App.console_log(f'raw errors: {error_result_set}')
             errors = []
             error_indexes = {}
             for row in error_result_set:
                 new_error = SQL_Error.from_db_error(row)
                 error_indexes[new_error.error_id] = len(errors)
                 errors.append(new_error)
-                Helper_App.console_log(f'error {str(type(new_error))}: {new_error}')
+                # Helper_App.console_log(f'error {str(type(new_error))}: {new_error}')
 
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
@@ -219,7 +219,7 @@ class DataStore_Base(BaseModel):
         arguments = Parameters_SQL_Error.get_default(guid)
         argument_dict = arguments.to_json()
         argument_types = Parameters_SQL_Error.get_type_hints()
-        Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
+        # Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
         
         cls.db_procedure_execute('tcg.public.USP_Error_Clear', argument_dict, argument_types)
 

datastores/datastore_mtg.py

@@ -18,6 +18,7 @@ from business_objects.tcg.mtg_game import MTG_Game, Parameters_MTG_Game
 from business_objects.tcg.mtg_game_player import MTG_Game_Player, Parameters_MTG_Game_Player, MTG_Game_Player_Temp
 from business_objects.tcg.mtg_game_round import MTG_Game_Round, Parameters_MTG_Game_Round, MTG_Game_Round_Temp
 from business_objects.tcg.mtg_game_round_player_damage import MTG_Game_Round_Player_Damage, Parameters_MTG_Game_Round_Player_Damage, MTG_Game_Round_Player_Damage_Temp
+from business_objects.tcg.mtg_game_session_member import MTG_Game_Session_Member, Parameters_MTG_Game_Session_Member
 from business_objects.tcg.statistic import Statistic, Statistic_Temp, Parameters_Statistic
 from business_objects.sql_error import SQL_Error, Parameters_SQL_Error
 from datastores.datastore_base import DataStore_Base
@@ -45,23 +46,23 @@ class DataStore_MTG(DataStore_Base):
         # user = cls.get_user_session()
         argument_dict = game_filters.to_json()
         argument_types = Parameters_MTG_Game.get_type_hints()
-        Helper_App.console_log(f'argument_dict: {argument_dict}')
+        # Helper_App.console_log(f'argument_dict: {argument_dict}')
         
         games = []
         errors = []
         try:
             game_result = cls.db_function_execute('tcg.public.FN_TCG_MTG_Game_Get_Many', argument_dict, argument_types)
             game_result_set = game_result.fetchall()
-            Helper_App.console_log(f'raw games: {game_result_set}')
+            # Helper_App.console_log(f'raw games: {game_result_set}')
             games = []
             game_indexes = {}
             for row in game_result_set:
                 new_game = MTG_Game.from_db_mtg_game(row)
                 game_indexes[new_game.game_id] = len(games)
                 games.append(new_game)
-                Helper_App.console_log(f'game {str(type(new_game))}: {new_game}')
+                # Helper_App.console_log(f'game {str(type(new_game))}: {new_game}')
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
@@ -109,7 +110,7 @@ class DataStore_MTG(DataStore_Base):
             , 'o_game_id': Integer
             , 'o_success': Boolean
         }
-        Helper_App.console_log(f'argument_dict: {argument_dict}')
+        # Helper_App.console_log(f'argument_dict: {argument_dict}')
         
         errors = []
         try:
@@ -117,12 +118,12 @@ class DataStore_MTG(DataStore_Base):
             row = rows[0] if rows else None
             game_id = row['o_game_id'] if row else None
             success = row['o_success'] if row else False
-            Helper_App.console_log(f'Game ID: {game_id}')
-            Helper_App.console_log(f'Success: {success}')
+            # Helper_App.console_log(f'Game ID: {game_id}')
+            # Helper_App.console_log(f'Success: {success}')
             if not success:
                 errors = cls.get_many_error(guid = guid)
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
@@ -136,20 +137,20 @@ class DataStore_MTG(DataStore_Base):
         _m = f'{cls.__qualname__}.get_many_mtg_game_player'
         argument_dict = player_filters.to_json()
         argument_types = Parameters_MTG_Game_Player.get_type_hints()
-        Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
+        # Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
 
         players = []
         errors = []
         try:
             result = cls.db_function_execute('tcg.public.FN_TCG_MTG_Game_Player_Get_Many', argument_dict, argument_types)
             result_set = result.fetchall()
-            Helper_App.console_log(f'raw players: {result_set}')
+            # Helper_App.console_log(f'raw players: {result_set}')
             for row in result_set:
                 new_player = MTG_Game_Player.from_db_mtg_game_player(row)
                 players.append(new_player)
-                Helper_App.console_log(f'player {str(type(new_player))}: {new_player}')
+                # Helper_App.console_log(f'player {str(type(new_player))}: {new_player}')
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
@@ -161,20 +162,20 @@ class DataStore_MTG(DataStore_Base):
         _m = f'{cls.__qualname__}.get_many_mtg_game_round'
         argument_dict = round_filters.to_json()
         argument_types = Parameters_MTG_Game_Round.get_type_hints()
-        Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
+        # Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
 
         rounds = []
         errors = []
         try:
             result = cls.db_function_execute('tcg.public.FN_TCG_MTG_Game_Round_Get_Many', argument_dict, argument_types)
             result_set = result.fetchall()
-            Helper_App.console_log(f'raw rounds: {result_set}')
+            # Helper_App.console_log(f'raw rounds: {result_set}')
             for row in result_set:
                 new_round = MTG_Game_Round.from_db_mtg_game_round(row)
                 rounds.append(new_round)
-                Helper_App.console_log(f'round {str(type(new_round))}: {new_round}')
+                # Helper_App.console_log(f'round {str(type(new_round))}: {new_round}')
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
@@ -186,20 +187,20 @@ class DataStore_MTG(DataStore_Base):
         _m = f'{cls.__qualname__}.get_many_mtg_game_round_player_damage'
         argument_dict = damage_filters.to_json()
         argument_types = Parameters_MTG_Game_Round_Player_Damage.get_type_hints()
-        Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
+        # Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
 
         damages = []
         errors = []
         try:
             result = cls.db_function_execute('tcg.public.FN_TCG_MTG_Game_Round_Player_Damage_Get_Many', argument_dict, argument_types)
             result_set = result.fetchall()
-            Helper_App.console_log(f'raw damages: {result_set}')
+            # Helper_App.console_log(f'raw damages: {result_set}')
             for row in result_set:
                 new_damage = MTG_Game_Round_Player_Damage.from_db_mtg_game_round_player_damage(row)
                 damages.append(new_damage)
-                Helper_App.console_log(f'damage {str(type(new_damage))}: {new_damage.damage_id}')
+                # Helper_App.console_log(f'damage {str(type(new_damage))}: {new_damage.damage_id}')
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
@@ -211,20 +212,20 @@ class DataStore_MTG(DataStore_Base):
         _m = f'{cls.__qualname__}.get_many_mtg_deck'
         argument_dict = deck_filters.to_json()
         argument_types = Parameters_MTG_Deck.get_type_hints()
-        Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
+        # Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
 
         decks = []
         errors = []
         try:
             result = cls.db_function_execute('tcg.public.FN_TCG_MTG_Deck_Get_Many', argument_dict, argument_types)
             result_set = result.fetchall()
-            Helper_App.console_log(f'raw decks: {result_set}')
+            # Helper_App.console_log(f'raw decks: {result_set}')
             for row in result_set:
                 new_deck = MTG_Deck.from_db_mtg_deck(row)
                 decks.append(new_deck)
-                Helper_App.console_log(f'deck {str(type(new_deck))}: {new_deck}')
+                # Helper_App.console_log(f'deck {str(type(new_deck))}: {new_deck}')
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
@@ -250,7 +251,7 @@ class DataStore_MTG(DataStore_Base):
             , 'a_user_id': Integer
             , 'o_success': Boolean
         }
-        Helper_App.console_log(f'argument_dict: {argument_dict}')
+        # Helper_App.console_log(f'argument_dict: {argument_dict}')
         
         objs_player_temp = []
         for player in players:
@@ -268,12 +269,12 @@ class DataStore_MTG(DataStore_Base):
             rows = cls.db_procedure_execute('tcg.public.USP_TCG_MTG_Game_Player_Save', argument_dict, argument_type_hints)
             row = rows[0] if rows else None
             success = row['o_success'] if row else False
-            Helper_App.console_log(f'Success: {success}')
+            # Helper_App.console_log(f'Success: {success}')
             if not success:
                 errors = cls.get_many_error(guid = guid)
-                Helper_App.console_log(f'Errors: {str(errors)}')
+                # Helper_App.console_log(f'Errors: {str(errors)}')
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
@@ -300,7 +301,7 @@ class DataStore_MTG(DataStore_Base):
             , 'a_user_id': Integer
             , 'o_success': Boolean
         }
-        Helper_App.console_log(f'argument_dict: {argument_dict}')
+        # Helper_App.console_log(f'argument_dict: {argument_dict}')
         
         objs_round_temp = []
         for round in rounds:
@@ -328,12 +329,12 @@ class DataStore_MTG(DataStore_Base):
             rows = cls.db_procedure_execute('tcg.public.USP_TCG_MTG_Game_Round_Damage_Save', argument_dict, argument_type_hints)
             row = rows[0] if rows else None
             success = row['o_success'] if row else False
-            Helper_App.console_log(f'Success: {success}')
+            # Helper_App.console_log(f'Success: {success}')
             if not success:
                 errors = cls.get_many_error(guid = guid)
-                Helper_App.console_log(f'Errors: {str(errors)}')
+                # Helper_App.console_log(f'Errors: {str(errors)}')
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
@@ -348,20 +349,20 @@ class DataStore_MTG(DataStore_Base):
         _m = f'{cls.__qualname__}.get_many_mtg_deck_commander_bracket'
         argument_dict = parameters_commander_bracket.to_json()
         argument_types = Parameters_MTG_Deck.get_type_hints()
-        Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
+        # Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
 
         commander_brackets = []
         errors = []
         try:
             result = cls.db_function_execute('tcg.public.FN_TCG_MTG_Deck_Commander_Bracket_Get_Many', argument_dict, argument_types)
             result_set = result.fetchall()
-            Helper_App.console_log(f'raw commander brackets: {result_set}')
+            # Helper_App.console_log(f'raw commander brackets: {result_set}')
             for row in result_set:
                 new_commander_bracket = MTG_Deck_Commander_Bracket.from_db_mtg_deck_commander_bracket(row)
                 commander_brackets.append(new_commander_bracket)
-                Helper_App.console_log(f'commander bracket {str(type(new_commander_bracket))}: {new_commander_bracket}')
+                # Helper_App.console_log(f'commander bracket {str(type(new_commander_bracket))}: {new_commander_bracket}')
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
@@ -374,22 +375,44 @@ class DataStore_MTG(DataStore_Base):
         _m = f'{cls.__qualname__}.get_many_statistic'
         argument_dict = parameters_statistic.to_json()
         argument_types = Parameters_MTG_Deck.get_type_hints()
-        Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
+        # Helper_App.console_log(f'{_m}\nargument_dict: {argument_dict}')
 
         statistics = []
         errors = []
         try:
             result = cls.db_function_execute('tcg.public.FN_TCG_Statistic_Get_Many', argument_dict, argument_types)
             result_set = result.fetchall()
-            Helper_App.console_log(f'raw commander brackets: {result_set}')
+            # Helper_App.console_log(f'raw commander brackets: {result_set}')
             for row in result_set:
                 new_statistic = Statistic.from_db_statistic(row)
                 statistics.append(new_statistic)
-                Helper_App.console_log(f'statistic {str(type(new_statistic))}: {new_statistic}')
+                # Helper_App.console_log(f'statistic {str(type(new_statistic))}: {new_statistic}')
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
 
-        return statistics, errors
+        return statistics,
+
+    @classmethod
+    def get_many_mtg_game_session_member(cls, member_filters):
+        argument_dict = member_filters.to_json()
+        argument_types = Parameters_MTG_Game_Session_Member.get_type_hints()
+
+        members = []
+        errors = []
+        try:
+            result = cls.db_function_execute('tcg.public.FN_TCG_MTG_Game_Session_Member_Get_Many', argument_dict, argument_types)
+            result_set = result.fetchall()
+            for row in result_set:
+                new_member = MTG_Game_Session_Member.from_db_mtg_game_player(row)
+                members.append(new_member)
+        except Exception as e:
+            error = SQL_Error()
+            error.msg = str(e)
+            errors.append(error)
+
+        return members, errors
+
+

datastores/datastore_user.py

@@ -15,6 +15,7 @@ Datastore for Users
 import lib.argument_validation as av
 from business_objects.sql_error import SQL_Error
 from business_objects.tcg.user import User, Parameters_User
+from business_objects.tcg.user_relationship import User_Relationship, Parameters_User_Relationship
 from datastores.datastore_base import DataStore_Base
 from helpers.helper_app import Helper_App
 from helpers.helper_db_sql import Helper_DB_SQL
@@ -41,33 +42,55 @@ class DataStore_User(DataStore_Base):
     @classmethod
     def get_many_user(cls, user_filters):
         _m = f'{cls.__qualname__}.get_many_user'
-        Helper_App.console_log(_m)
-        Helper_App.console_log(f'user_filters: {user_filters}')
+        # Helper_App.console_log(_m)
+        # Helper_App.console_log(f'user_filters: {user_filters}')
         av.val_instance(user_filters, 'user_filters', _m, Parameters_User)
 
         argument_dict = user_filters.to_json()
-        Helper_App.console_log(f'argument_dict: {argument_dict}')
+        # Helper_App.console_log(f'argument_dict: {argument_dict}')
 
         users = []
         errors = []
         try:
             user_result = cls.db_function_execute('tcg.public.FN_TCG_User_Get_Many', argument_dict, Parameters_User.get_type_hints())
             user_result_set = user_result.fetchall()
-            Helper_App.console_log(f'raw users: {user_result_set}')
+            # Helper_App.console_log(f'raw users: {user_result_set}')
 
             for row in user_result_set:
-                Helper_App.console_log(f'row: {row}')
+                # Helper_App.console_log(f'row: {row}')
                 user = User.from_db_user(row)
                 users.append(user)
-                Helper_App.console_log(f'user {str(type(user))}: {user}')
+                # Helper_App.console_log(f'user {str(type(user))}: {user}')
         except Exception as e:
-            Helper_App.console_log(f'Error: {str(e)}')
+            # Helper_App.console_log(f'Error: {str(e)}')
             error = SQL_Error()
             error.msg = str(e)
             errors.append(error)
 
         return users, errors
 
+    @classmethod
+    def get_many_user_relationship(cls, relationship_filters):
+        _m = f'{cls.__qualname__}.get_many_user_relationship'
+        av.val_instance(relationship_filters, 'relationship_filters', _m, Parameters_User_Relationship)
+
+        argument_dict = relationship_filters.to_json()
+
+        relationships = []
+        errors = []
+        try:
+            result = cls.db_function_execute('tcg.public.FN_TCG_User_Relationship_Get_Many', argument_dict, Parameters_User_Relationship.get_type_hints())
+            result_set = result.fetchall()
+            for row in result_set:
+                relationship = User_Relationship.from_db_user_relationship(row)
+                relationships.append(relationship)
+        except Exception as e:
+            error = SQL_Error()
+            error.msg = str(e)
+            errors.append(error)
+
+        return relationships, errors
+
     @classmethod
     def login_user(cls, user):
         _m = f'{cls}.login_user'
@@ -75,7 +98,7 @@ class DataStore_User(DataStore_Base):
 
         guid = Helper_DB_SQL.create_guid_str()
 
-        Helper_App.console_log(f'login user: {user}')
+        # Helper_App.console_log(f'login user: {user}')
 
         success = False
         user_id = None
@@ -92,8 +115,8 @@ class DataStore_User(DataStore_Base):
             row = rows[0] if rows else None
             success = row['o_success'] if row else False
             user_id = row['o_user_id'] if row else None
-            Helper_App.console_log('User logged in')
-            Helper_App.console_log(f'Success: {success}\nUser ID: {user_id}')
+            # Helper_App.console_log('User logged in')
+            # Helper_App.console_log(f'Success: {success}\nUser ID: {user_id}')
 
             user.user_id = user_id
             user_filters = Parameters_User.from_user(user)